diff options
author | joseph <joseph@7b3dc134-2b1b-0410-93df-9e9f96275f8d> | 2013-06-04 15:48:26 +0000 |
---|---|---|
committer | joseph <joseph@7b3dc134-2b1b-0410-93df-9e9f96275f8d> | 2013-06-04 15:48:26 +0000 |
commit | 8548b3be8c48bf62bd4e20fb0ee958338b01bc6c (patch) | |
tree | 874deff152fded2f5b50110ee6d488d42605bb01 | |
parent | eab7f6089510455a9b26643c64da331749a15650 (diff) | |
download | eglibc2-8548b3be8c48bf62bd4e20fb0ee958338b01bc6c.tar.gz |
Merge changes between r23097 and r23217 from /fsf/trunk.
git-svn-id: svn://svn.eglibc.org/trunk@23218 7b3dc134-2b1b-0410-93df-9e9f96275f8d
153 files changed, 26294 insertions, 19881 deletions
diff --git a/libc/ChangeLog b/libc/ChangeLog index fe2a64471..91a183ad8 100644 --- a/libc/ChangeLog +++ b/libc/ChangeLog @@ -1,3 +1,902 @@ +2013-06-03 Carlos O'Donell <carlos@redhat.com> + + [BZ #15536] + * math/libm-test.inc (MAX_EXP): Remove + (MIN_EXP): Define. + (ulp): Use MIN_EXP - MANT_DIG. + (check_ulp): Verify subnormal ulps. Only allow a range of +/- 1 ulp. + +2013-05-31 Carlos O'Donell <carlos@redhat.com> + + * po/be.po: Revert last change. + * po/zh_CN.po: Likewise. + * po/header.pot: Likewise. + +2013-05-31 Joseph Myers <joseph@codesourcery.com> + + * Makefile ($(common-objpfx)linkobj/libc.so): Define + link-libc-deps to empty as target-specific variable. + * Makerules (link-libc-args): New variable. + (libc-for-link): Likewise. + (link-libc-deps): Likewise. + (lib%.so): Depend on $(link-libc-deps). Link with + $(link-libc-args). + (build-module): Link with $(link-libc-args). + (build-module-asneeded): Likewise. + (build-module-helper-objlist): Filter out $(link-libc-deps) from + list of objects. + ($(common-objpfx)libc.so): Define link-libc-deps to empty as + target-specific variable. + ($(extra-modules-build:%=$(objpfx)%.so)): Depend on + $(link-libc-deps) instead of libc.so and libc_nonshared.a. + * crypt/Makefile ($(objpfx)libcrypt.so): Remove dependencies on + libc. + * debug/Makefile ($(objpfx)libSegFault.so): Remove dependencies on + libc and ld.so. + ($(objpfx)libpcprofile.so): Likewise. + * dlfcn/Makefile (LDLIBS-bug-atexit3-lib.so): Remove ld.so and + libc_nonshared.a. + ($(objpfx)libdl.so): Remove dependencies on libc and ld.so. + * hesiod/Makefile ($(objpfx)libnss_hesiod.so): Likewise. + * iconvdata/extra-module.mk ($(objpfx)$(mod).so): Depend on + $(link-libc-deps). + ($(objpfx)$(mod).so): Remove dependencies on libc and ld.so. + * locale/Makefile ($(objpfx)libBrokenLocale.so): Likewise. + * login/Makefile ($(objpfx)libutil.so): Likewise. + * malloc/Makefile ($(objpfx)libmemusage.so): Likewise. + * math/Makefile ($(objpfx)libm.so): Likewise. + * nis/Makefile ($(services:%=$(objpfx)libnss_%.so) + $(objpfx)libnsl.so): Define libc-for-link as target-specific + variable instead of depending directly on libc. + * nss/Makefile ($(services:%=$(objpfx)libnss_%.so)): Likewise. + ($(objpfx)/libnss_test1.so): Change dependencies on libc to + $(link-libc-deps). + * resolv/Makefile ($(objpfx)libresolv.so): Remove dependencies on + libc. + [$(have-ssp) = yes] (LDLIBS-resolv.so): Remove variable. + ($(objpfx)libnss_dns.so): Remove dependencies on libc. + ($(objpfx)libanl.so): Likewise. + * rt/Makefile ($(objpfx)librt.so): Remove dependencies on libc and + ld.so. + * stdlib/Makefile ($(objpfx)tst-putenvmod.so): Depend on + $(link-libc-deps). + * sysdeps/i386/fpu/Makefile: Remove file. + * sysdeps/powerpc/fpu/Makefile [$(subdir) = math] + ($(objpfx)libm.so): Remove dependency on ld.so. + +2013-05-30 Patsy Franklin <pfrankli@redhat.com> + + [BZ # 15553] + * nis/yp_xdr.c (XDRMAXNAME): Define. + (XDRMAXRECORD): Define. + (xdr_domainname): Use XDRMAXNAME. + (xdr_mapname): Likewise. + (xdr_peername): Likewise. + (xdr_keydat): Use XDRMAXRECORD. + (xdr_valdat): Likewise. + +2013-05-30 Jeff Law <law@redhat.com> + + [BZ #14256] + * manual/errno.texi (ESTALE): Update to account for more than + just NFS file systems. + * sysdeps/gnu/errlist.c: Regenerated. + +2013-05-29 Siddhesh Poyarekar <siddhesh@redhat.com> + + [BZ #15465] + * elf/Makefile (tests): Add tst-null-argv. + (modules-names): Add tst-null-argv-lib. + ($(objpfx)tst-null-argv): Depend on tst-null-argv-lib.so. + (tst-null-argv-ENV): Set environment for tst-null-argv. + * sysdeps/generic/ldsodefs.h (DSO_FILENAME): New macro. + (RTLD_PROGNAME): New macro. + * elf/tst-null-argv.c: New test case. + * elf/tst-null-argv-lib.c: Library for test case. + * elf/dl-conflict.c (_dl_resolve_conflicts): Use DSO_FILENAME. + * elf/dl-deps.c (_dl_map_object_deps): Likewise. + * elf/dl-error.c (_dl_signal_error): Use RTLD_PROGNAME. + * elf/dl-fini.c (_dl_fini): Use DSO_FILENAME. + * elf/dl-init.c (call_init): Likewise. + (_dl_init): Likewise. + * elf/dl-load.c (print_search_path): Likewise. + (_dl_map_object): Likewise. + * elf/dl-lookup.c (do_lookup_x): Likewise. + (add_dependency): Likewise. + (_dl_lookup_symbol_x): Likewise. + (_dl_debug_bindings): Likewise. + * elf/dl-open.c (_dl_show_scope): Likewise. + * elf/dl-reloc.c (_dl_relocate_object): Likewise. + * elf/dl-version.c (match_symbol): Likewise. + (_dl_check_map_versions): Likewise. + * elf/rtld.c (dl_main): Likewise. + (print_unresolved): Use RTLD_PROGNAME. + (print_missing_version): Likewise. + * sysdeps/i386/dl-machine.h (elf_machine_rel): Likewise. + (elf_machine_rela): Likewise. + * sysdeps/powerpc/powerpc32/dl-machine.c + (__process_machine_rela): Likewise. + * sysdeps/powerpc/powerpc64/dl-machine.h (elf_machine_rela): + Likewise. + * sysdeps/s390/s390-32/dl-machine.h (elf_machine_rela): + Likewise. + * sysdeps/s390/s390-64/dl-machine.h (elf_machine_rela): + Likewise. + * sysdeps/sh/dl-machine.h (elf_machine_rela): Likewise. + * sysdeps/sparc/sparc32/dl-machine.h (elf_machine_rela): + Likewise. + * sysdeps/sparc/sparc64/dl-machine.h (elf_machine_rela): + Likewise. + * sysdeps/x86_64/dl-machine.h (elf_machine_rela): Likewise. + +2013-05-28 Carlos O'Donell <carlos@redhat.com> + + * po/be.po: Add descriptive title. + * po/zh_CN.po: Likewise. + * po/header.pot: Likewise. + +2013-05-28 Mike Frysinger <vapier@gentoo.org> + + * locale/programs/locarchive.c (create_archive): Inlucde fname in + error message. + (enlarge_archive): Likewise. + +2013-05-28 Ben North <ben@redfrontdoor.org> + + * manual/arith.texi (frexp): It is the magnitude of the return + value which lies in [0.5, 1), not the return value itself. + +2013-05-28 Adhemerval Zanella <azanella@linux.vnet.ibm.com> + + * sysdeps/powerpc/fpu/libm-test-ulps: Update. + +2013-05-26 Thomas Schwinge <thomas@codesourcery.com> + + * stdio-common/bug26.c (main): Correct fscanf template. + + * sysdeps/mach/hurd/dl-sysdep.c (_dl_sysdep_start:go): Don't + declare _dl_skip_args. + + * sysdeps/mach/hurd/i386/init-first.c (_dl_non_dynamic_init): + Don't declare. + + * manual/platform.texi: Add missing @end deftypefun. + +2013-05-24 Joseph Myers <joseph@codesourcery.com> + + [BZ #15529] + * sysdeps/ieee754/ldbl-96/e_hypotl.c (__ieee754_hypotl): Set high + bit of mantissa of 2^16382. + * math/libm-test.inc (hypot_test_data): Add more tests. + + * math/libm-test.inc: Add drem and pow10 to list of tested + functions. + (pow10_test): New function. + (drem_test): Likewise. + (drem_test_tonearest): Likewise. + (drem_test_towardzero): Likewise. + (drem_test_downward): Likewise. + (drem_test_upward): Likewise. + (main): Call the new functions. + + * math/libm-test.inc (finite_test_data): Remove. + (finite_test): Run tests from isfinite_test_data. + (gamma_test_data): Remove. + (gamma_test): Run tests from lgamma_test_data. + * sysdeps/i386/fpu/libm-test-ulps: Update. + * sysdeps/x86_64/fpu/libm-test-ulps: Likewise. + +2013-05-24 Adhemerval Zanella <azanella@linux.vnet.ibm.com> + + * manual/platform.texi: Add PowerPC PPR function set documentation. + * sysdeps/powerpc/sys/platform/ppc.h: Add PowerPC PPR set function + implementation. + +2013-05-24 Carlos O'Donell <carlos@redhat.com> + + * math/libm-test.inc (MAX_EXP): Define. + (ULPDIFF): Define. + (ulp): New function. + (check_float_internal): Use ULPDIFF. + (cpow_test): Disable failing test. + (check_ulp): Test ulp() implemetnation. + (main): Call check_ulp before starting tests. + +2013-05-24 Joseph Myers <joseph@codesourcery.com> + + * math/gen-libm-test.pl (generate_testfile): Do not handle + START_DATA and END_DATA. + * math/libm-test.inc (acos_test_data): Do not use START_DATA and + END_DATA. + (acos_tonearest_test_data): Likewise. + (acos_towardzero_test_data): Likewise. + (acos_downward_test_data): Likewise. + (acos_upward_test_data): Likewise. + (acosh_test_data): Likewise. + (asin_test_data): Likewise. + (asin_tonearest_test_data): Likewise. + (asin_towardzero_test_data): Likewise. + (asin_downward_test_data): Likewise. + (asin_upward_test_data): Likewise. + (asinh_test_data): Likewise. + (atan_test_data): Likewise. + (atanh_test_data): Likewise. + (atan2_test_data): Likewise. + (cabs_test_data): Likewise. + (cacos_test_data): Likewise. + (cacosh_test_data): Likewise. + (carg_test_data): Likewise. + (casin_test_data): Likewise. + (casinh_test_data): Likewise. + (catan_test_data): Likewise. + (catanh_test_data): Likewise. + (cbrt_test_data): Likewise. + (ccos_test_data): Likewise. + (ccosh_test_data): Likewise. + (ceil_test_data): Likewise. + (cexp_test_data): Likewise. + (cimag_test_data): Likewise. + (clog_test_data): Likewise. + (clog10_test_data): Likewise. + (conj_test_data): Likewise. + (copysign_test_data): Likewise. + (cos_test_data): Likewise. + (cos_tonearest_test_data): Likewise. + (cos_towardzero_test_data): Likewise. + (cos_downward_test_data): Likewise. + (cos_upward_test_data): Likewise. + (cosh_test_data): Likewise. + (cosh_tonearest_test_data): Likewise. + (cosh_towardzero_test_data): Likewise. + (cosh_downward_test_data): Likewise. + (cosh_upward_test_data): Likewise. + (cpow_test_data): Likewise. + (cproj_test_data): Likewise. + (creal_test_data): Likewise. + (csin_test_data): Likewise. + (csinh_test_data): Likewise. + (csqrt_test_data): Likewise. + (ctan_test_data): Likewise. + (ctan_tonearest_test_data): Likewise. + (ctan_towardzero_test_data): Likewise. + (ctan_downward_test_data): Likewise. + (ctan_upward_test_data): Likewise. + (ctanh_test_data): Likewise. + (ctanh_tonearest_test_data): Likewise. + (ctanh_towardzero_test_data): Likewise. + (ctanh_downward_test_data): Likewise. + (ctanh_upward_test_data): Likewise. + (erf_test_data): Likewise. + (erfc_test_data): Likewise. + (exp_test_data): Likewise. + (exp_tonearest_test_data): Likewise. + (exp_towardzero_test_data): Likewise. + (exp_downward_test_data): Likewise. + (exp_upward_test_data): Likewise. + (exp10_test_data): Likewise. + (exp2_test_data): Likewise. + (expm1_test_data): Likewise. + (fabs_test_data): Likewise. + (fdim_test_data): Likewise. + (finite_test_data): Likewise. + (floor_test_data): Likewise. + (fma_test_data): Likewise. + (fma_towardzero_test_data): Likewise. + (fma_downward_test_data): Likewise. + (fma_upward_test_data): Likewise. + (fmax_test_data): Likewise. + (fmin_test_data): Likewise. + (fmod_test_data): Likewise. + (fpclassify_test_data): Likewise. + (frexp_test_data): Likewise. + (gamma_test_data): Likewise. + (hypot_test_data): Likewise. + (ilogb_test_data): Likewise. + (isfinite_test_data): Likewise. + (isgreater_test_data): Likewise. + (isgreaterequal_test_data): Likewise. + (isinf_test_data): Likewise. + (isless_test_data): Likewise. + (islessequal_test_data): Likewise. + (islessgreater_test_data): Likewise. + (isnan_test_data): Likewise. + (isnormal_test_data): Likewise. + (issignaling_test_data): Likewise. + (isunordered_test_data): Likewise. + (j0_test_data): Likewise. + (j1_test_data): Likewise. + (jn_test_data): Likewise. + (ldexp_test_data): Likewise. + (lgamma_test_data): Likewise. + (lrint_test_data): Likewise. + (lrint_tonearest_test_data): Likewise. + (lrint_towardzero_test_data): Likewise. + (lrint_downward_test_data): Likewise. + (lrint_upward_test_data): Likewise. + (llrint_test_data): Likewise. + (llrint_tonearest_test_data): Likewise. + (llrint_towardzero_test_data): Likewise. + (llrint_downward_test_data): Likewise. + (llrint_upward_test_data): Likewise. + (log_test_data): Likewise. + (log10_test_data): Likewise. + (log1p_test_data): Likewise. + (log2_test_data): Likewise. + (logb_test_data): Likewise. + (logb_downward_test_data): Likewise. + (lround_test_data): Likewise. + (llround_test_data): Likewise. + (modf_test_data): Likewise. + (nearbyint_test_data): Likewise. + (nextafter_test_data): Likewise. + (nexttoward_test_data): Likewise. + (pow_test_data): Likewise. + (pow_tonearest_test_data): Likewise. + (pow_towardzero_test_data): Likewise. + (pow_downward_test_data): Likewise. + (pow_upward_test_data): Likewise. + (remainder_test_data): Likewise. + (remainder_tonearest_test_data): Likewise. + (remainder_towardzero_test_data): Likewise. + (remainder_downward_test_data): Likewise. + (remainder_upward_test_data): Likewise. + (remquo_test_data): Likewise. + (rint_test_data): Likewise. + (rint_tonearest_test_data): Likewise. + (rint_towardzero_test_data): Likewise. + (rint_downward_test_data): Likewise. + (rint_upward_test_data): Likewise. + (round_test_data): Likewise. + (scalb_test_data): Likewise. + (scalbn_test_data): Likewise. + (scalbln_test_data): Likewise. + (signbit_test_data): Likewise. + (sin_test_data): Likewise. + (sin_tonearest_test_data): Likewise. + (sin_towardzero_test_data): Likewise. + (sin_downward_test_data): Likewise. + (sin_upward_test_data): Likewise. + (sincos_test_data): Likewise. + (sinh_test_data): Likewise. + (sinh_tonearest_test_data): Likewise. + (sinh_towardzero_test_data): Likewise. + (sinh_downward_test_data): Likewise. + (sinh_upward_test_data): Likewise. + (sqrt_test_data): Likewise. + (tan_test_data): Likewise. + (tan_tonearest_test_data): Likewise. + (tan_towardzero_test_data): Likewise. + (tan_downward_test_data): Likewise. + (tan_upward_test_data): Likewise. + (tanh_test_data): Likewise. + (tgamma_test_data): Likewise. + (trunc_test_data): Likewise. + (y0_test_data): Likewise. + (y1_test_data): Likewise. + (yn_test_data): Likewise. + (significand_test_data): Likewise. + + * math/gen-libm-test.pl (@functions): Remove variable. + (generate_testfile): Don't handle START and END lines. + * math/libm-test.inc (START): New macro. + (END): Likewise. + (END_COMPLEX): Likewise. + (acos_test): Use END macro without arguments. + (acos_test_tonearest): Likewise. + (acos_test_towardzero): Likewise. + (acos_test_downward): Likewise. + (acos_test_upward): Likewise. + (acosh_test): Likewise. + (asin_test): Likewise. + (asin_test_tonearest): Likewise. + (asin_test_towardzero): Likewise. + (asin_test_downward): Likewise. + (asin_test_upward): Likewise. + (asinh_test): Likewise. + (atan_test): Likewise. + (atanh_test): Likewise. + (atan2_test): Likewise. + (cabs_test): Likewise. + (cacos_test): Use END_COMPLEX macro without arguments. + (cacosh_test): Likewise. + (carg_test): Use END macro without arguments. + (casin_test): Use END_COMPLEX macro without arguments. + (casinh_test): Likewise. + (catan_test): Likewise. + (catanh_test): Likewise. + (cbrt_test): Use END macro without arguments. + (ccos_test): Use END_COMPLEX macro without arguments. + (ccosh_test): Likewise. + (ceil_test): Use END macro without arguments. + (cexp_test): Use END_COMPLEX macro without arguments. + (cimag_test): Use END macro without arguments. + (clog_test): Use END_COMPLEX macro without arguments. + (clog10_test): Likewise. + (conj_test): Likewise. + (copysign_test): Use END macro without arguments. + (cos_test): Likewise. + (cos_test_tonearest): Likewise. + (cos_test_towardzero): Likewise. + (cos_test_downward): Likewise. + (cos_test_upward): Likewise. + (cosh_test): Likewise. + (cosh_test_tonearest): Likewise. + (cosh_test_towardzero): Likewise. + (cosh_test_downward): Likewise. + (cosh_test_upward): Likewise. + (cpow_test): Use END_COMPLEX macro without arguments. + (cproj_test): Likewise. + (creal_test): Use END macro without arguments. + (csin_test): Use END_COMPLEX macro without arguments. + (csinh_test): Likewise. + (csqrt_test): Likewise. + (ctan_test): Likewise. + (ctan_test_tonearest): Likewise. + (ctan_test_towardzero): Likewise. + (ctan_test_downward): Likewise. + (ctan_test_upward): Likewise. + (ctanh_test): Likewise. + (ctanh_test_tonearest): Likewise. + (ctanh_test_towardzero): Likewise. + (ctanh_test_downward): Likewise. + (ctanh_test_upward): Likewise. + (erf_test): Use END macro without arguments. + (erfc_test): Likewise. + (exp_test): Likewise. + (exp_test_tonearest): Likewise. + (exp_test_towardzero): Likewise. + (exp_test_downward): Likewise. + (exp_test_upward): Likewise. + (exp10_test): Likewise. + (exp2_test): Likewise. + (expm1_test): Likewise. + (fabs_test): Likewise. + (fdim_test): Likewise. + (finite_test): Likewise. + (floor_test): Likewise. + (fma_test): Likewise. + (fma_test_towardzero): Likewise. + (fma_test_downward): Likewise. + (fma_test_upward): Likewise. + (fmax_test): Likewise. + (fmin_test): Likewise. + (fmod_test): Likewise. + (fpclassify_test): Likewise. + (frexp_test): Likewise. + (gamma_test): Likewise. + (hypot_test): Likewise. + (ilogb_test): Likewise. + (isfinite_test): Likewise. + (isgreater_test): Likewise. + (isgreaterequal_test): Likewise. + (isinf_test): Likewise. + (isless_test): Likewise. + (islessequal_test): Likewise. + (islessgreater_test): Likewise. + (isnan_test): Likewise. + (isnormal_test): Likewise. + (issignaling_test): Likewise. + (isunordered_test): Likewise. + (j0_test): Likewise. + (j1_test): Likewise. + (jn_test): Likewise. + (ldexp_test): Likewise. + (lgamma_test): Likewise. + (lrint_test): Likewise. + (lrint_test_tonearest): Likewise. + (lrint_test_towardzero): Likewise. + (lrint_test_downward): Likewise. + (lrint_test_upward): Likewise. + (llrint_test): Likewise. + (llrint_test_tonearest): Likewise. + (llrint_test_towardzero): Likewise. + (llrint_test_downward): Likewise. + (llrint_test_upward): Likewise. + (log_test): Likewise. + (log10_test): Likewise. + (log1p_test): Likewise. + (log2_test): Likewise. + (logb_test): Likewise. + (logb_test_downward): Likewise. + (lround_test): Likewise. + (llround_test): Likewise. + (modf_test): Likewise. + (nearbyint_test): Likewise. + (nextafter_test): Likewise. + (nexttoward_test): Likewise. + (pow_test): Likewise. + (pow_test_tonearest): Likewise. + (pow_test_towardzero): Likewise. + (pow_test_downward): Likewise. + (pow_test_upward): Likewise. + (remainder_test): Likewise. + (remainder_test_tonearest): Likewise. + (remainder_test_towardzero): Likewise. + (remainder_test_downward): Likewise. + (remainder_test_upward): Likewise. + (remquo_test): Likewise. + (rint_test): Likewise. + (rint_test_tonearest): Likewise. + (rint_test_towardzero): Likewise. + (rint_test_downward): Likewise. + (rint_test_upward): Likewise. + (round_test): Likewise. + (scalb_test): Likewise. + (scalbn_test): Likewise. + (scalbln_test): Likewise. + (signbit_test): Likewise. + (sin_test): Likewise. + (sin_test_tonearest): Likewise. + (sin_test_towardzero): Likewise. + (sin_test_downward): Likewise. + (sin_test_upward): Likewise. + (sincos_test): Likewise. + (sinh_test): Likewise. + (sinh_test_tonearest): Likewise. + (sinh_test_towardzero): Likewise. + (sinh_test_downward): Likewise. + (sinh_test_upward): Likewise. + (sqrt_test): Likewise. + (tan_test): Likewise. + (tan_test_tonearest): Likewise. + (tan_test_towardzero): Likewise. + (tan_test_downward): Likewise. + (tan_test_upward): Likewise. + (tanh_test): Likewise. + (tgamma_test): Likewise. + (trunc_test): Likewise. + (y0_test): Likewise. + (y1_test): Likewise. + (yn_test): Likewise. + (significand_test): Likewise. + +2013-05-24 OndÅ™ej BÃlka <neleai@seznam.cz> + + [BZ #15381] + * libio/genops.c (_IO_no_init): Initialize wide struct info. + +2013-05-23 Edjunior Machado <emachado@linux.vnet.ibm.com> + + [BZ #14894] + * sysdeps/powerpc/sys/platform/ppc.h: Add __ppc_yield, + __ppc_mdoio and __ppc_mdoom. + * manual/platform.texi: Document new functions __ppc_yield, + __ppc_mdoio and __ppc_mdoom. + +2013-05-22 Carlos O'Donell <carlos@redhat.com> + + * elf/ldconfig.c (is_hwcap_platform): Make comments full setences. + (main): Mention "tls" pseudo-hwcap is legacy. + * elf/dl-hwcaps.c (_dl_important_hwcaps): Correct rounding comment. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * math/gen-libm-test.pl (parse_args): Output only string of + arguments as text for test name, not full call or descriptions of + tests for extra outputs. + (generate_testfile): Do not pass function name to parse_args. + Generate this_func variable from START. + * math/libm-test.inc (struct test_f_f_data): Rename test_name + field to arg_str. + (struct test_ff_f_data): Likewise. + (test_ff_f_data_nexttoward): Likewise. + (struct test_fi_f_data): Likewise. + (struct test_fl_f_data): Likewise. + (struct test_if_f_data): Likewise. + (struct test_fff_f_data): Likewise. + (struct test_c_f_data): Likewise. + (struct test_f_f1_data): Likewise. Remove field extra_name. + (struct test_fF_f1_data): Likewise. + (struct test_ffI_f1_data): Likewise. + (struct test_c_c_data): Rename test_name field to arg_str. + (struct test_cc_c_data): Likewise. + (struct test_f_i_data): Likewise. + (struct test_ff_i_data): Likewise. + (struct test_f_l_data): Likewise. + (struct test_f_L_data): Likewise. + (struct test_fFF_11_data): Likewise. Remove fields extra1_name + and extra2_name. + (COMMON_TEST_SETUP): New macro. + (EXTRA_OUTPUT_TEST_SETUP): Likewise. + (COMMON_TEST_CLEANUP): Likewise. + (EXTRA_OUTPUT_TEST_CLEANUP): Likewise. + (RUN_TEST_f_f): Take argument string. Call new setup and cleanup + macros. + (RUN_TEST_LOOP_f_f): Update call to RUN_TEST_f_f. + (RUN_TEST_2_f): Take argument string. Call new setup and cleanup + macros. + (RUN_TEST_LOOP_2_f): Update call to RUN_TEST_2_f. + (RUN_TEST_fff_f): Take argument string. Call new setup and + cleanup macros. + (RUN_TEST_LOOP_fff_f): Update call to RUN_TEST_fff_f. + (RUN_TEST_c_f): Take argument string. Call new setup and cleanup + macros. + (RUN_TEST_LOOP_c_f): Update call to RUN_TEST_c_f. + (RUN_TEST_f_f1): Take argument string. Call new setup and cleanup + macros. + (RUN_TEST_LOOP_f_f1): Update call to RUN_TEST_f_f1. + (RUN_TEST_fF_f1): Take argument string. Call new setup and + cleanup macros. + (RUN_TEST_LOOP_fF_f1): Update call to RUN_TEST_fF_f1. + (RUN_TEST_fI_f1): Take argument string. Call new setup and + cleanup macros. + (RUN_TEST_LOOP_fI_f1): Update call to RUN_TEST_fI_f1. + (RUN_TEST_ffI_f1): Take argument string. Call new setup and + cleanup macros. + (RUN_TEST_LOOP_ffI_f1): Update call to RUN_TEST_ffI_f1. + (RUN_TEST_c_c): Take argument string. Call new setup and cleanup + macros. + (RUN_TEST_LOOP_c_c): Update call to RUN_TEST_c_c. + (RUN_TEST_cc_c): Take argument string. Call new setup and cleanup + macros. + (RUN_TEST_LOOP_cc_c): Update call to RUN_TEST_cc_c. + (RUN_TEST_f_i): Take argument string. Call new setup and cleanup + macros. + (RUN_TEST_LOOP_f_i): Update call to RUN_TEST_f_i. + (RUN_TEST_f_i_tg): Take argument string. Call new setup and + cleanup macros. + (RUN_TEST_LOOP_f_i_tg): Update call to RUN_TEST_f_i_tg. + (RUN_TEST_ff_i_tg): Take argument string. Call new setup and + cleanup macros. + (RUN_TEST_LOOP_ff_i_tg): Update call to RUN_TEST_ff_i_tg. + (RUN_TEST_f_b): Take argument string. Call new setup and cleanup + macros. + (RUN_TEST_LOOP_f_b): Update call to RUN_TEST_f_b. + (RUN_TEST_f_b_tg): Take argument string. Call new setup and + cleanup macros. + (RUN_TEST_LOOP_f_b_tg): Update call to RUN_TEST_f_b_tg. + (RUN_TEST_f_l): Take argument string. Call new setup and cleanup + macros. + (RUN_TEST_LOOP_f_l): Update call to RUN_TEST_f_l. + (RUN_TEST_f_L): Take argument string. Call new setup and cleanup + macros. + (RUN_TEST_LOOP_f_L): Update call to RUN_TEST_f_L. + (RUN_TEST_fFF_11): Take argument string. Call new setup and + cleanup macros. + (RUN_TEST_LOOP_fFF_11): Update call to RUN_TEST_fFF_11. + +2013-05-22 Edjunior Barbosa Machado <emachado@linux.vnet.ibm.com> + + * sysdeps/unix/sysv/linux/bits/siginfo.h (siginfo_t): Add si_addr_lsb + to _sifields.sigfault. + (si_addr_lsb): Define new macro. + (BUS_MCEERR_AR, BUS_MCEERR_AO): Define new values. + * sysdeps/unix/sysv/linux/sparc/bits/siginfo.h: Likewise. + * sysdeps/unix/sysv/linux/x86/bits/siginfo.h: Likewise. + +2013-05-03 Carlos O'Donell <carlos at redhat.com> + + [BZ #15441] + * intl/dcigettext.c (DCIGETTEXT): Skip translating if _nl_find_msg + returns -1. + (_nl_find_msg): Return -1 if recursive call returned -1. If newmem is + null return -1. + * intl/loadmsgcat.c (_nl_load_domain): If _nl_find_msg returns -1 abort + loading the domain. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * math/gen-libm-test.pl (parse_args): Do not include expected + result in test name. + * sysdeps/i386/fpu/libm-test-ulps: Update test names. + * sysdeps/powerpc/fpu/libm-test-ulps: Likewise. + * sysdeps/s390/fpu/libm-test-ulps: Likewise. + * sysdeps/sh/sh4/fpu/libm-test-ulps: Likewise. + * sysdeps/sparc/fpu/libm-test-ulps: Likewise. + * sysdeps/x86_64/fpu/libm-test-ulps: Likewise. + +2013-05-22 Siddhesh Poyarekar <siddhesh@redhat.com> + + * benchtests/Makefile: Sort function entries. + + * benchtests/Makefile (bench): Add asin, acos, sinh, cosh, + tanh, asinh, acosh, atanh. + * benchtests/acos-inputs: New file. + * benchtests/acosh-inputs: New file. + * benchtests/asin-inputs: New file. + * benchtests/asinh-inputs: New file. + * benchtests/atanh-inputs: New file. + * benchtests/cosh-inputs: New file. + * benchtests/log-inputs: New file. + * benchtests/sinh-inputs: New file. + * benchtests/tanh-inputs: New file. + +2013-05-21 Dmitry V. Levin <ldv@altlinux.org> + + [BZ #15339] + * posix/tst-getaddrinfo4.c: New test. + * posix/Makefile (tests): Add it. + +2013-05-21 Siddhesh Poyarekar <siddhesh@redhat.com> + + [BZ #15339] + * nss/getXXbyYY_r.c (REENTRANT_NAME): Set NETDB_INTERNAL only + when no services were used. + * sysdeps/posix/getaddrinfo.c (gaih_inet): Set h_errno. + Return EAI_SYSTEM if h_errno is NETDB_INTERNAL. + +2013-05-21 Andreas Schwab <schwab@suse.de> + + [BZ #15014] + * nss/getXXbyYY_r.c (INTERNAL (REENTRANT_NAME)) + [HANDLE_DIGITS_DOTS]: Set any_service when digits-dots parsing was + successful. + * nss/digits_dots.c (__nss_hostname_digits_dots): Remove + redundant variable declarations and reallocation of buffer when + parsing as IPv6 address. Always set NSS status when called from + reentrant functions. Use NETDB_INTERNAL instead of TRY_AGAIN when + buffer too small. Correct computation of needed size. + * nss/Makefile (tests): Add test-digits-dots. + * nss/test-digits-dots.c: New test. + +2013-05-21 Siddhesh Poyarekar <siddhesh@redhat.com> + + * benchtests/Makefile: Remove instructions for adding + benchmark tests. + * benchtests/README: New file to explain how to execute and + enhance the benchmark tests. + +2013-05-21 Andreas Schwab <schwab@suse.de> + + [BZ #15493] + * setjmp/Makefile (tests): Add tst-sigsetjmp. + * setjmp/tst-sigsetjmp.c: New test. + +2013-05-20 OndÅ™ej BÃlka <neleai@seznam.cz> + + * sysdeps/x86_64/memset.S (memset): New implementation. + (__bzero): Likewise. + (__memset_tail): New function. + +2013-05-20 OndÅ™ej BÃlka <neleai@seznam.cz> + + * sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S: New file. + * sysdeps/x86_64/multiarch/memcpy.S (__new_memcpy): Add + __memcpy_sse2_unaligned ifunc selection. + * sysdeps/x86_64/multiarch/Makefile (sysdep_routines): + Add memcpy-sse2-unaligned.S. + * sysdeps/x86_64/multiarch/ifunc-impl-list.c (__libc_ifunc_impl_list): + Add: __memcpy_sse2_unaligned. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + [BZ #15490] + * sysdeps/ieee754/dbl-64/s_nearbyint.c (__nearbyint): Use + math_force_eval before restoring floating-point envrionment. + * sysdeps/ieee754/flt-32/s_nearbyintf.c (__nearbyintf): Likewise. + * sysdeps/ieee754/ldbl-128/s_nearbyintl.c (__nearbyintl): + Likewise. + * sysdeps/ieee754/ldbl-128ibm/s_nearbyintl.c: Include + <math_private.h>. + (__nearbyintl): Use math_force_eval before restoring + floating-point environment. + * sysdeps/ieee754/ldbl-96/s_nearbyintl.c (__nearbyintl): Likewise. + + * math/gen-libm-test.pl (special_functions): Remove. + (parse_args): Don't handle TEST_extra. Handle functions with no + return value. + * math/libm-test.inc (struct test_sincos_data): Replace with + struct test_fFF_11_data. + (RUN_TEST_sincos): Replace with RUN_TEST_fFF_11. + (RUN_TEST_LOOP_sincos): Replace with RUN_TEST_LOOP_fFF_11. + (sincos_test_data): Change element type to struct + test_fFF_11_data. Use TEST_fFF_11 instead of TEST_extra. + (sincos_test): Use RUN_TEST_LOOP_fFF_11 instead of + RUN_TEST_LOOP_sincos. + * math/README.libm-test: Don't mention special handling of + individual functions. + * sysdeps/i386/fpu/libm-test-ulps: Update names of sincos tests. + * sysdeps/powerpc/fpu/libm-test-ulps: Likewise. + * sysdeps/s390/fpu/libm-test-ulps: Likewise. + * sysdeps/sh/sh4/fpu/libm-test-ulps: Likewise. + * sysdeps/sparc/fpu/libm-test-ulps: Likewise. + * sysdeps/x86_64/fpu/libm-test-ulps: Likewise. + + * math/gen-libm-test.pl (get_variable): Remove function. + (parse_args): Don't show pointer parameters to call in test + names. Use "extra output N" in test names for extra outputs + rather than naming variables. + +2013-05-18 Joseph Myers <joseph@codesourcery.com> + + [BZ #15488] + * math/complex.h [__USE_ISOC11 && __GNUC_PREREQ (4, 7) && + __NO_LONG_DOUBLE_MATH] (CMPLXL): Define macro. + * math/tst-CMPLX.c (do_test) [NO_LONG_DOUBLE]: Do not disable long + double tests. + * make/tst-CMPLX2.c [NO_LONG_DOUBLE] (check_long_double): Do not + disable. + (do_test) [NO_LONG_DOUBLE]: Do not disable call to + check_long_double. + + * math/gen-libm-test.pl (@tests): Remove variable. + ($count): Likewise. + (new_test): Remove function. + (show_exceptions): New function. + (special_functions): Use show_exceptions instead of new_test. + (parse_args): Likewise. + (generate_testfile): Pass only function name in generated call to + print_max_error or print_complex_max_error. + (get_ulps): Do not handle complex tests specially. + (output_test): Rename to ... + (get_all_ulps_for_test): ... this. Return a string rather than + printing to a file. Require ulps to be present. + (output_ulps): Generate arrays rather than #defines. + * math/libm-test.inc: Move down #include of "libm-test-ulps.h". + (struct ulp_data): New type. + (BUILD_COMPLEX_ULP): Remove macro. + (compare_ulp_data): New function. + (find_ulps): Likewise. + (find_test_ulps): Likewise. + (find_function_ulps): Likewise. + (find_complex_function_ulps): Likewise. + (print_max_error): Determine allowed ulps using + find_function_ulps. + (print_complex_max_error): Determine allowed ulps using + find_complex_function_ulps. + (check_float_internal): Determine max ulps using find_test_ulps. + (check_float): Do not take max_ulp parameter. Update call to + check_float_internal. + (check_complex): Likewise. + (check_int): Do not take max_ulp parameter. + (check_long): Likewise. + (check_bool): Likewise. + (check_longlong): Likewise. + (struct test_f_f_data): Remove max_ulp field. + (struct test_ff_f_data): Likewise. + (struct test_ff_f_data_nexttoward): Likewise. + (struct test_fi_f_data): Likewise. + (struct test_fl_f_data): Likewise. + (struct test_if_f_data): Likewise. + (struct test_fff_f_data): Likewise. + (struct test_c_f_data): Likewise. + (struct test_f_f1_data): Remove max_ulp and extra_ulp fields. + (struct test_fF_f1_data): Likewise. + (struct test_ffI_f1_data): Likewise. + (struct test_c_c_data): Remove max_ulp field. + (struct test_cc_c_data): Likewise. + (struct test_f_i_data): Likewise. + (struct test_ff_i_data): Likewise. + (struct test_f_l_data): Likewise. + (struct test_f_L_data): Likewise. + (struct test_sincos_data): Likewise. + (RUN_TEST_f_f): Do not handle ulps. + (RUN_TEST_LOOP_f_f): Likewise. + (RUN_TEST_2_f): Likewise. + (RUN_TEST_LOOP_2_f): Likewise. + (RUN_TEST_fff_f): Likewise. + (RUN_TEST_LOOP_fff_f): Likewise. + (RUN_TEST_c_f): Likewise. + (RUN_TEST_LOOP_c_f): Likewise. + (RUN_TEST_f_f1): Likewise. + (RUN_TEST_LOOP_f_f1): Likewise. + (RUN_TEST_fF_f1): Likewise. + (RUN_TEST_LOOP_fF_f1): Likewise. + (RUN_TEST_fI_f1): Likewise. + (RUN_TEST_LOOP_fI_f1): Likewise. + (RUN_TEST_ffI_f1): Likewise. + (RUN_TEST_LOOP_ffI_f1): Likewise. + (RUN_TEST_c_c): Likewise. + (RUN_TEST_LOOP_c_c): Likewise. + (RUN_TEST_cc_c): Likewise. + (RUN_TEST_LOOP_cc_c): Likewise. + (RUN_TEST_f_i): Likewise. + (RUN_TEST_LOOP_f_i): Likewise. + (RUN_TEST_f_i_tg): Likewise. + (RUN_TEST_LOOP_f_i_tg): Likewise. + (RUN_TEST_ff_i_tg): Likewise. + (RUN_TEST_LOOP_ff_i_tg): Likewise. + (RUN_TEST_f_b): Likewise. + (RUN_TEST_LOOP_f_b): Likewise. + (RUN_TEST_f_b_tg): Likewise. + (RUN_TEST_LOOP_f_b_tg): Likewise. + (RUN_TEST_f_l): Likewise. + (RUN_TEST_LOOP_f_l): Likewise. + (RUN_TEST_f_L): Likewise. + (RUN_TEST_LOOP_f_L): Likewise. + (RUN_TEST_sincos): Likewise. + (RUN_TEST_LOOP_sincos): Likewise. + 2013-05-17 Joseph Myers <joseph@codesourcery.com> [BZ #15480] @@ -121,6 +1020,7 @@ 2013-05-17 Adhemerval Zanella <azanella@linux.vnet.ibm.com> + [BZ # 15497] * sysdeps/powerpc/fpu/e_hypot.c (GET_TWO_FLOAT_WORD): Fix test for negative infinity on POWER6 or lower. * sysdeps/powerpc/fpu/e_hypotf.c (GET_TWO_FLOAT_WORD): Likewise. diff --git a/libc/Makefile b/libc/Makefile index 662e1a095..51d10b97b 100644 --- a/libc/Makefile +++ b/libc/Makefile @@ -136,6 +136,9 @@ lib: $(common-objpfx)libc.so lib: $(common-objpfx)linkobj/libc.so +# Do not filter ld.so out of libc.so link. +$(common-objpfx)linkobj/libc.so: link-libc-deps = # empty + $(common-objpfx)linkobj/libc.so: $(elfobjdir)/soinit.os \ $(common-objpfx)linkobj/libc_pic.a \ $(elfobjdir)/sofini.os \ diff --git a/libc/Makerules b/libc/Makerules index db7ca5f46..760f3aa07 100644 --- a/libc/Makerules +++ b/libc/Makerules @@ -455,13 +455,33 @@ map-file = $(firstword $($(@F:.so=-map)) \ load-map-file = $(map-file:%=-Wl,--version-script=%) # eglibc: endif +# Compiler arguments to use to link a shared object with libc and +# ld.so. This is intended to be as similar as possible to a default +# link with an installed libc. +link-libc-args = -Wl,--start-group \ + $(libc-for-link) \ + $(common-objpfx)libc_nonshared.a \ + $(as-needed) $(elfobjdir)/ld.so $(no-as-needed) \ + -Wl,--end-group + +# The corresponding shared libc to use. This may be modified for a +# particular target. +libc-for-link = $(common-objpfx)libc.so + +# The corresponding dependencies. As these are used in dependencies, +# not just commands, they cannot use target-specific variables so need +# to name both possible libc.so objects. +link-libc-deps = $(common-objpfx)libc.so $(common-objpfx)linkobj/libc.so \ + $(common-objpfx)libc_nonshared.a $(elfobjdir)/ld.so + # Pattern rule to build a shared object from an archive of PIC objects. # This must come after the installation rules so Make doesn't try to # build shared libraries in place from the installed *_pic.a files. # $(LDLIBS-%.so) may contain -l switches to generate run-time dependencies -# on other shared objects. -lib%.so: lib%_pic.a $(+preinit) $(+postinit) $(+interp) - $(build-shlib) +# on other shared objects. The linking with libc and ld.so is intended +# to be as similar as possible to a default link with an installed libc. +lib%.so: lib%_pic.a $(+preinit) $(+postinit) $(+interp) $(link-libc-deps) + $(build-shlib) $(link-libc-args) define build-shlib-helper $(LINK.o) -shared $(static-libgcc) -Wl,-O1 $(sysdep-LDFLAGS) \ @@ -536,17 +556,19 @@ endef # not for shared objects define build-module $(build-module-helper) -o $@ $(shlib-lds-flags) \ - $(csu-objpfx)abi-note.o $(build-module-objlist) + $(csu-objpfx)abi-note.o $(build-module-objlist) $(link-libc-args) endef define build-module-asneeded $(build-module-helper) -o $@ $(shlib-lds-flags) \ $(csu-objpfx)abi-note.o \ - -Wl,--as-needed $(build-module-objlist) -Wl,--no-as-needed + -Wl,--as-needed $(build-module-objlist) -Wl,--no-as-needed \ + $(link-libc-args) endef build-module-helper-objlist = \ $(patsubst %_pic.a,$(whole-archive) %_pic.a $(no-whole-archive),\ - $(filter-out %.lds $(map-file) $(+preinit) $(+postinit),$^)) + $(filter-out %.lds $(map-file) $(+preinit) $(+postinit) \ + $(link-libc-deps),$^)) build-module-objlist = $(build-module-helper-objlist) $(LDLIBS-$(@F:%.so=%).so) build-shlib-objlist = $(build-module-helper-objlist) \ @@ -595,6 +617,10 @@ ifneq ($(versioning),yes) # libgcc_eh to get _Unwind_Find_FDE. libc_gcclibs := -lgcc_eh endif + +# Do not filter ld.so out of libc.so link. +$(common-objpfx)libc.so: link-libc-deps = # empty + # Use our own special initializer and finalizer files for libc.so. $(common-objpfx)libc.so: $(elfobjdir)/soinit.os \ $(common-objpfx)libc_pic.os$(libc_pic_clean) \ @@ -653,8 +679,7 @@ include $(patsubst %,$(..)extra-modules.mk,$(modules-names)) extra-modules-build := $(filter-out $(modules-names-nobuild),$(modules-names)) $(extra-modules-build:%=$(objpfx)%.so): $(objpfx)%.so: \ - $(objpfx)%.os $(shlib-lds) \ - $(common-objpfx)libc.so $(common-objpfx)libc_nonshared.a + $(objpfx)%.os $(shlib-lds) $(link-libs-deps) $(build-module) endif @@ -10,14 +10,16 @@ Version 2.18 * The following bugs are resolved with this release: 2546, 2560, 5159, 6809, 10060, 10062, 10357, 10686, 11120, 11561, 12387, - 12723, 13550, 13889, 13951, 13988, 14142, 14176, 14200, 14280, 14293, - 14317, 14327, 14478, 14496, 14582, 14686, 14812, 14888, 14908, 14920, - 14952, 14964, 14981, 14982, 14985, 14994, 14996, 15000, 15003, 15006, - 15007, 15020, 15023, 15036, 15054, 15055, 15062, 15078, 15084, 15085, - 15086, 15160, 15214, 15221, 15232, 15234, 15283, 15285, 15287, 15304, - 15305, 15307, 15309, 15327, 15330, 15335, 15336, 15337, 15342, 15346, - 15359, 15361, 15366, 15380, 15394, 15395, 15405, 15406, 15409, 15416, - 15418, 15419, 15423, 15424, 15426, 15429, 15442, 15448, 15480, 15485. + 12723, 13550, 13889, 13951, 13988, 14142, 14176, 14200, 14256, 14280, + 14293, 14317, 14327, 14478, 14496, 14582, 14686, 14812, 14888, 14894, + 14908, 14920, 14952, 14964, 14981, 14982, 14985, 14994, 14996, 15000, + 15003, 15006, 15007, 15014, 15020, 15023, 15036, 15054, 15055, 15062, + 15078, 15084, 15085, 15086, 15160, 15214, 15221, 15232, 15234, 15283, + 15285, 15287, 15304, 15305, 15307, 15309, 15327, 15330, 15335, 15336, + 15337, 15339, 15342, 15346, 15359, 15361, 15366, 15380, 15381, 15394, + 15395, 15405, 15406, 15409, 15416, 15418, 15419, 15423, 15424, 15426, + 15429, 15441, 15442, 15448, 15465, 15480, 15485, 15488, 15490, 15493, + 15497, 15506, 15529, 15536, 15553. * CVE-2013-0242 Buffer overrun in regexp matcher has been fixed (Bugzilla #15078). diff --git a/libc/benchtests/Makefile b/libc/benchtests/Makefile index 861839013..67728537a 100644 --- a/libc/benchtests/Makefile +++ b/libc/benchtests/Makefile @@ -17,34 +17,52 @@ # Makefile for benchmark tests. The only useful target here is `bench`. +# Add benchmark functions in alphabetical order. -# Adding a new function `foo`: -# --------------------------- +subdir := benchtests +bench := acos acosh asin asinh atan atanh cos cosh exp log modf pow rint sin \ + sinh tan tanh -# - Append the function name to the bench variable +acos-ARGLIST = double +acos-RET = double +LDFLAGS-bench-acos = -lm -# - Define foo-ARGLIST as a colon separated list of types of the input -# arguments. Use `void` if function does not take any inputs. Put in quotes -# if the input argument is a pointer, e.g.: +acosh-ARGLIST = double +acosh-RET = double +LDFLAGS-bench-acosh = -lm -# malloc-ARGLIST: "void *" +asin-ARGLIST = double +asin-RET = double +LDFLAGS-bench-asin = -lm -# - Define foo-RET as the type the function returns. Skip if the function -# returns void. One could even skip foo-ARGLIST if the function does not -# take any inputs AND the function returns void. +asinh-ARGLIST = double +asinh-RET = double +LDFLAGS-bench-asinh = -lm +atan-ARGLIST = double +atan-RET = double +LDFLAGS-bench-atan = -lm -# - Make a file called `foo-inputs` with one input value per line, an input -# being a comma separated list of arguments to be passed into the function. -# See pow-inputs for an example. +atanh-ARGLIST = double +atanh-RET = double +LDFLAGS-bench-atanh = -lm -subdir := benchtests -bench := exp pow rint sin cos tan atan modf +cos-ARGLIST = double +cos-RET = double +LDFLAGS-bench-cos = -lm + +cosh-ARGLIST = double +cosh-RET = double +LDFLAGS-bench-cosh = -lm exp-ARGLIST = double exp-RET = double LDFLAGS-bench-exp = -lm +log-ARGLIST = double +log-RET = double +LDFLAGS-bench-log = -lm + pow-ARGLIST = double:double pow-RET = double LDFLAGS-bench-pow = -lm @@ -57,17 +75,17 @@ sin-ARGLIST = double sin-RET = double LDFLAGS-bench-sin = -lm -cos-ARGLIST = double -cos-RET = double -LDFLAGS-bench-cos = -lm +sinh-ARGLIST = double +sinh-RET = double +LDFLAGS-bench-sinh = -lm tan-ARGLIST = double tan-RET = double LDFLAGS-bench-tan = -lm -atan-ARGLIST = double -atan-RET = double -LDFLAGS-bench-atan = -lm +tanh-ARGLIST = double +tanh-RET = double +LDFLAGS-bench-tanh = -lm diff --git a/libc/benchtests/README b/libc/benchtests/README new file mode 100644 index 000000000..8135069fe --- /dev/null +++ b/libc/benchtests/README @@ -0,0 +1,74 @@ +Using the glibc microbenchmark suite +==================================== + +The glibc microbenchmark suite automatically generates code for specified +functions, builds and calls them repeatedly for given inputs to give some +basic performance properties of the function. + +Running the benchmark: +===================== + +The benchmark can be executed by invoking make as follows: + + $ make bench + +This runs each function for 10 seconds and appends its output to +benchtests/bench.out. To ensure that the tests are rebuilt, one could run: + + $ make bench-clean + +The duration of each test can be configured setting the BENCH_DURATION variable +in the call to make. One should run `make bench-clean' before changing +BENCH_DURATION. + + $ make BENCH_DURATION=1 bench + +The benchmark suite does function call measurements using architecture-specific +high precision timing instructions whenever available. When such support is +not available, it uses clock_gettime (CLOCK_PROCESS_CPUTIME_ID). One can force +the benchmark to use clock_gettime by invoking make as follows: + + $ make USE_CLOCK_GETTIME=1 bench + +Again, one must run `make bench-clean' before changing the measurement method. + +Adding a function to benchtests: +=============================== + +If the name of the function is `foo', then the following procedure should allow +one to add `foo' to the bench tests: + +- Append the function name to the bench variable in the Makefile. + +- Define foo-ARGLIST as a colon separated list of types of the input + arguments. Use `void' if function does not take any inputs. Put in quotes + if the input argument is a pointer, e.g.: + + malloc-ARGLIST: "void *" + +- Define foo-RET as the type the function returns. Skip if the function + returns void. One could even skip foo-ARGLIST if the function does not + take any inputs AND the function returns void. + +- Make a file called `foo-inputs` with one input value per line, an input + being a comma separated list of arguments to be passed into the function. + See pow-inputs for an example. + + The script that parses the -inputs file treats lines beginning with a single + `#' as comments. Lines beginning with two hashes `##' are treated specially + as `directives'. + +Multiple execution units per function: +===================================== + +Some functions have distinct performance characteristics for different input +domains and it may be necessary to measure those separately. For example, some +math functions perform computations at different levels of precision (64-bit vs +240-bit vs 768-bit) and mixing them does not give a very useful picture of the +performance of these functions. One could separate inputs for these domains in +the same file by using the `name' directive that looks something like this: + + ##name: 240bit + +See the pow-inputs file for an example of what such a partitioned input file +would look like. diff --git a/libc/benchtests/acos-inputs b/libc/benchtests/acos-inputs new file mode 100644 index 000000000..b527af35e --- /dev/null +++ b/libc/benchtests/acos-inputs @@ -0,0 +1,7 @@ +0.5 +0.1 +0.2 +0.3 +0.4 +0.8 +0.7 diff --git a/libc/benchtests/acosh-inputs b/libc/benchtests/acosh-inputs new file mode 100644 index 000000000..3c8c546f0 --- /dev/null +++ b/libc/benchtests/acosh-inputs @@ -0,0 +1,5 @@ +0.1 +0.2 +0.3 +0.4 +0.5 diff --git a/libc/benchtests/asin-inputs b/libc/benchtests/asin-inputs new file mode 100644 index 000000000..b527af35e --- /dev/null +++ b/libc/benchtests/asin-inputs @@ -0,0 +1,7 @@ +0.5 +0.1 +0.2 +0.3 +0.4 +0.8 +0.7 diff --git a/libc/benchtests/asinh-inputs b/libc/benchtests/asinh-inputs new file mode 100644 index 000000000..3c8c546f0 --- /dev/null +++ b/libc/benchtests/asinh-inputs @@ -0,0 +1,5 @@ +0.1 +0.2 +0.3 +0.4 +0.5 diff --git a/libc/benchtests/atanh-inputs b/libc/benchtests/atanh-inputs new file mode 100644 index 000000000..3c8c546f0 --- /dev/null +++ b/libc/benchtests/atanh-inputs @@ -0,0 +1,5 @@ +0.1 +0.2 +0.3 +0.4 +0.5 diff --git a/libc/benchtests/cosh-inputs b/libc/benchtests/cosh-inputs new file mode 100644 index 000000000..3c8c546f0 --- /dev/null +++ b/libc/benchtests/cosh-inputs @@ -0,0 +1,5 @@ +0.1 +0.2 +0.3 +0.4 +0.5 diff --git a/libc/benchtests/log-inputs b/libc/benchtests/log-inputs new file mode 100644 index 000000000..713c2229f --- /dev/null +++ b/libc/benchtests/log-inputs @@ -0,0 +1 @@ +42.0 diff --git a/libc/benchtests/sinh-inputs b/libc/benchtests/sinh-inputs new file mode 100644 index 000000000..3c8c546f0 --- /dev/null +++ b/libc/benchtests/sinh-inputs @@ -0,0 +1,5 @@ +0.1 +0.2 +0.3 +0.4 +0.5 diff --git a/libc/benchtests/tanh-inputs b/libc/benchtests/tanh-inputs new file mode 100644 index 000000000..3c8c546f0 --- /dev/null +++ b/libc/benchtests/tanh-inputs @@ -0,0 +1,5 @@ +0.1 +0.2 +0.3 +0.4 +0.5 diff --git a/libc/crypt/Makefile b/libc/crypt/Makefile index c0a6efd9e..a65b36f97 100644 --- a/libc/crypt/Makefile +++ b/libc/crypt/Makefile @@ -75,8 +75,3 @@ else $(addprefix $(objpfx),$(tests)): $(objpfx)libcrypt.a endif endif # eglibc: OPTION_EGLIBC_CRYPT - -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -$(objpfx)libcrypt.so: $(common-objpfx)libc.so $(common-objpfx)libc_nonshared.a diff --git a/libc/debug/Makefile b/libc/debug/Makefile index 45e2d8e5c..626d18f2c 100644 --- a/libc/debug/Makefile +++ b/libc/debug/Makefile @@ -201,13 +201,3 @@ $(objpfx)xtrace: xtrace.sh -e 's|@PKGVERSION@|$(PKGVERSION)|' \ -e 's|@REPORT_BUGS_TO@|$(REPORT_BUGS_TO)|' $^ > $@.new \ && rm -f $@ && mv $@.new $@ && chmod +x $@ - -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -$(objpfx)libSegFault.so: $(common-objpfx)libc.so \ - $(common-objpfx)libc_nonshared.a \ - $(elf-objpfx)$(rtld-installed-name) -$(objpfx)libpcprofile.so: $(common-objpfx)libc.so \ - $(common-objpfx)libc_nonshared.a \ - $(elf-objpfx)$(rtld-installed-name) diff --git a/libc/dlfcn/Makefile b/libc/dlfcn/Makefile index eac58a53d..04bbbd903 100644 --- a/libc/dlfcn/Makefile +++ b/libc/dlfcn/Makefile @@ -121,14 +121,6 @@ $(objpfx)bug-atexit1.out: $(objpfx)bug-atexit1-lib.so $(objpfx)bug-atexit2: $(libdl) $(objpfx)bug-atexit2.out: $(objpfx)bug-atexit2-lib.so -LDLIBS-bug-atexit3-lib.so = -lstdc++ -lgcc_eh $(elfobjdir)/ld.so \ - $(common-objpfx)libc_nonshared.a +LDLIBS-bug-atexit3-lib.so = -lstdc++ -lgcc_eh $(objpfx)bug-atexit3: $(libdl) $(objpfx)bug-atexit3.out: $(objpfx)bug-atexit3-lib.so - - -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -$(objpfx)libdl.so: $(common-objpfx)libc.so $(common-objpfx)libc_nonshared.a \ - $(elfobjdir)/ld.so diff --git a/libc/elf/Makefile b/libc/elf/Makefile index 713e64100..838f1e6b0 100644 --- a/libc/elf/Makefile +++ b/libc/elf/Makefile @@ -145,7 +145,7 @@ tests += loadtest restest1 preloadtest loadfail multiload origtest resolvfail \ tst-audit1 tst-audit2 tst-audit8 \ tst-stackguard1 tst-addr1 tst-thrlock \ tst-unique1 tst-unique2 tst-unique3 tst-unique4 \ - tst-initorder tst-initorder2 tst-relsort1 + tst-initorder tst-initorder2 tst-relsort1 tst-null-argv # reldep9 test-srcs = tst-pathopt selinux-enabled := $(shell cat /selinux/enforce 2> /dev/null) @@ -208,7 +208,7 @@ modules-names = testobj1 testobj2 testobj3 testobj4 testobj5 testobj6 \ tst-initorder2a tst-initorder2b tst-initorder2c \ tst-initorder2d \ tst-relsort1mod1 tst-relsort1mod2 tst-array2dep \ - tst-array5dep + tst-array5dep tst-null-argv-lib ifeq (yesyes,$(have-fpie)$(build-shared)) modules-names += tst-piemod1 tests += tst-pie1 @@ -494,7 +494,9 @@ $(objpfx)tst-initorderb2.so: $(objpfx)tst-initorderb1.so $(objpfx)tst-initordera $(objpfx)tst-initordera3.so: $(objpfx)tst-initorderb2.so $(objpfx)tst-initorderb1.so $(objpfx)tst-initordera4.so: $(objpfx)tst-initordera3.so $(objpfx)tst-initorder: $(objpfx)tst-initordera4.so $(objpfx)tst-initordera1.so $(objpfx)tst-initorderb2.so +$(objpfx)tst-null-argv: $(objpfx)tst-null-argv-lib.so +tst-null-argv-ENV = LD_DEBUG=all LD_DEBUG_OUTPUT=$(objpfx)tst-null-argv.debug.out LDFLAGS-nodel2mod3.so = $(no-as-needed) LDFLAGS-reldepmod5.so = $(no-as-needed) LDFLAGS-reldep6mod1.so = $(no-as-needed) diff --git a/libc/elf/dl-conflict.c b/libc/elf/dl-conflict.c index e5b04e298..25271b131 100644 --- a/libc/elf/dl-conflict.c +++ b/libc/elf/dl-conflict.c @@ -33,8 +33,7 @@ _dl_resolve_conflicts (struct link_map *l, ElfW(Rela) *conflict, { #if ! ELF_MACHINE_NO_RELA if (__builtin_expect (GLRO_dl_debug_mask & DL_DEBUG_RELOC, 0)) - _dl_debug_printf ("\nconflict processing: %s\n", - l->l_name[0] ? l->l_name : rtld_progname); + _dl_debug_printf ("\nconflict processing: %s\n", DSO_FILENAME (l->l_name)); { /* Do the conflict relocation of the object and library GOT and other diff --git a/libc/elf/dl-deps.c b/libc/elf/dl-deps.c index 1916f96df..6cdb3b8e5 100644 --- a/libc/elf/dl-deps.c +++ b/libc/elf/dl-deps.c @@ -310,8 +310,7 @@ _dl_map_object_deps (struct link_map *map, _dl_debug_printf ("load auxiliary object=%s" " requested by file=%s\n", name, - l->l_name[0] - ? l->l_name : rtld_progname); + DSO_FILENAME (l->l_name)); /* We must be prepared that the addressed shared object is not available. */ @@ -337,8 +336,7 @@ _dl_map_object_deps (struct link_map *map, _dl_debug_printf ("load filtered object=%s" " requested by file=%s\n", name, - l->l_name[0] - ? l->l_name : rtld_progname); + DSO_FILENAME (l->l_name)); /* For filter objects the dependency must be available. */ bool malloced; diff --git a/libc/elf/dl-error.c b/libc/elf/dl-error.c index e1ab57731..4cee614f0 100644 --- a/libc/elf/dl-error.c +++ b/libc/elf/dl-error.c @@ -119,7 +119,7 @@ _dl_signal_error (int errcode, const char *objname, const char *occation, /* Lossage while resolving the program's own symbols is always fatal. */ char buffer[1024]; _dl_fatal_printf ("%s: %s: %s%s%s%s%s\n", - rtld_progname ?: "<program name unknown>", + RTLD_PROGNAME, occation ?: N_("error while loading shared libraries"), objname, *objname ? ": " : "", errstring, errcode ? ": " : "", diff --git a/libc/elf/dl-fini.c b/libc/elf/dl-fini.c index dea8fdcbb..3d559291b 100644 --- a/libc/elf/dl-fini.c +++ b/libc/elf/dl-fini.c @@ -237,7 +237,7 @@ _dl_fini (void) if (__builtin_expect (GLRO_dl_debug_mask & DL_DEBUG_IMPCALLS, 0)) _dl_debug_printf ("\ncalling fini: %s [%lu]\n\n", - l->l_name[0] ? l->l_name : rtld_progname, + DSO_FILENAME (l->l_name), ns); /* First see whether an array is given. */ diff --git a/libc/elf/dl-hwcaps.c b/libc/elf/dl-hwcaps.c index 1b7fe52a6..94cbf6cc2 100644 --- a/libc/elf/dl-hwcaps.c +++ b/libc/elf/dl-hwcaps.c @@ -68,9 +68,9 @@ _dl_important_hwcaps (const char *platform, size_t platform_len, size_t *sz, + GLRO(dl_sysinfo_map)->l_addr); /* The standard ELF note layout is exactly as the anonymous struct. The next element is a variable length vendor name of length - VENDORLEN (with a real length rounded to ElfW(Addr)), followed + VENDORLEN (with a real length rounded to ElfW(Word)), followed by the data of length DATALEN (with a real length rounded to - ElfW(Addr)). */ + ElfW(Word)). */ const struct { ElfW(Word) vendorlen; diff --git a/libc/elf/dl-init.c b/libc/elf/dl-init.c index 44f4a8f9b..b5513263d 100644 --- a/libc/elf/dl-init.c +++ b/libc/elf/dl-init.c @@ -54,7 +54,7 @@ call_init (struct link_map *l, int argc, char **argv, char **env) /* Print a debug message if wanted. */ if (__builtin_expect (GLRO_dl_debug_mask & DL_DEBUG_IMPCALLS, 0)) _dl_debug_printf ("\ncalling init: %s\n\n", - l->l_name[0] ? l->l_name : rtld_progname); + DSO_FILENAME (l->l_name)); /* Now run the local constructors. There are two forms of them: - the one named by DT_INIT @@ -110,8 +110,7 @@ _dl_init (struct link_map *main_map, int argc, char **argv, char **env) if (__builtin_expect (GLRO_dl_debug_mask & DL_DEBUG_IMPCALLS, 0)) _dl_debug_printf ("\ncalling preinit: %s\n\n", - main_map->l_name[0] - ? main_map->l_name : rtld_progname); + DSO_FILENAME (main_map->l_name)); addrs = (ElfW(Addr) *) (preinit_array->d_un.d_ptr + main_map->l_addr); for (cnt = 0; cnt < i; ++cnt) diff --git a/libc/elf/dl-load.c b/libc/elf/dl-load.c index c0ec8f88b..3db7d5b46 100644 --- a/libc/elf/dl-load.c +++ b/libc/elf/dl-load.c @@ -1655,7 +1655,7 @@ print_search_path (struct r_search_path_elem **list, if (name != NULL) _dl_debug_printf_c ("\t\t(%s from file %s)\n", what, - name[0] ? name : rtld_progname); + DSO_FILENAME (name)); else _dl_debug_printf_c ("\t\t(%s)\n", what); } @@ -2128,8 +2128,7 @@ _dl_map_object (struct link_map *loader, const char *name, _dl_debug_printf ((mode & __RTLD_CALLMAP) == 0 ? "\nfile=%s [%lu]; needed by %s [%lu]\n" : "\nfile=%s [%lu]; dynamically loaded by %s [%lu]\n", - name, nsid, loader->l_name[0] - ? loader->l_name : rtld_progname, loader->l_ns); + name, nsid, DSO_FILENAME (loader->l_name), loader->l_ns); #ifdef SHARED /* Give the auditing libraries a chance to change the name before we diff --git a/libc/elf/dl-lookup.c b/libc/elf/dl-lookup.c index 84b4b3dfb..ffed011aa 100644 --- a/libc/elf/dl-lookup.c +++ b/libc/elf/dl-lookup.c @@ -112,8 +112,7 @@ do_lookup_x (const char *undef_name, uint_fast32_t new_hash, /* Print some debugging info if wanted. */ if (__builtin_expect (GLRO_dl_debug_mask & DL_DEBUG_SYMBOLS, 0)) _dl_debug_printf ("symbol=%s; lookup in file=%s [%lu]\n", - undef_name, - map->l_name[0] ? map->l_name : rtld_progname, + undef_name, DSO_FILENAME (map->l_name), map->l_ns); /* If the hash table is empty there is nothing to do here. */ @@ -667,10 +666,9 @@ add_dependency (struct link_map *undef_map, struct link_map *map, int flags) if (__builtin_expect (GLRO_dl_debug_mask & DL_DEBUG_FILES, 0)) _dl_debug_printf ("\ \nfile=%s [%lu]; needed by %s [%lu] (relocation dependency)\n\n", - map->l_name[0] ? map->l_name : rtld_progname, + DSO_FILENAME (map->l_name), map->l_ns, - undef_map->l_name[0] - ? undef_map->l_name : rtld_progname, + DSO_FILENAME (undef_map->l_name), undef_map->l_ns); } else @@ -751,9 +749,7 @@ _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map, const char *reference_name = undef_map ? undef_map->l_name : NULL; /* XXX We cannot translate the message. */ - _dl_signal_cerror (0, (reference_name[0] - ? reference_name - : (rtld_progname ?: "<main program>")), + _dl_signal_cerror (0, DSO_FILENAME (reference_name), N_("relocation error"), make_string ("symbol ", undef_name, ", version ", version->name, @@ -780,9 +776,7 @@ _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map, ? version->name : ""); /* XXX We cannot translate the message. */ - _dl_signal_cerror (0, (reference_name[0] - ? reference_name - : (rtld_progname ?: "<main program>")), + _dl_signal_cerror (0, DSO_FILENAME (reference_name), N_("symbol lookup error"), make_string (undefined_msg, undef_name, versionstr, versionname)); @@ -912,11 +906,9 @@ _dl_debug_bindings (const char *undef_name, struct link_map *undef_map, if (GLRO_dl_debug_mask & DL_DEBUG_BINDINGS) { _dl_debug_printf ("binding file %s [%lu] to %s [%lu]: %s symbol `%s'", - (reference_name[0] - ? reference_name - : (rtld_progname ?: "<main program>")), + DSO_FILENAME (reference_name), undef_map->l_ns, - value->m->l_name[0] ? value->m->l_name : rtld_progname, + DSO_FILENAME (value->m->l_name), value->m->l_ns, protected ? "protected" : "normal", undef_name); if (version) diff --git a/libc/elf/dl-open.c b/libc/elf/dl-open.c index bb0023222..4a6a89470 100644 --- a/libc/elf/dl-open.c +++ b/libc/elf/dl-open.c @@ -733,7 +733,7 @@ void _dl_show_scope (struct link_map *l, int from) { _dl_debug_printf ("object=%s [%lu]\n", - *l->l_name ? l->l_name : rtld_progname, l->l_ns); + DSO_FILENAME (l->l_name), l->l_ns); if (l->l_scope != NULL) for (int scope_cnt = from; l->l_scope[scope_cnt] != NULL; ++scope_cnt) { @@ -744,7 +744,7 @@ _dl_show_scope (struct link_map *l, int from) _dl_debug_printf_c (" %s", l->l_scope[scope_cnt]->r_list[cnt]->l_name); else - _dl_debug_printf_c (" %s", rtld_progname); + _dl_debug_printf_c (" %s", RTLD_PROGNAME); _dl_debug_printf_c ("\n"); } diff --git a/libc/elf/dl-reloc.c b/libc/elf/dl-reloc.c index 902992b65..a0d3662b1 100644 --- a/libc/elf/dl-reloc.c +++ b/libc/elf/dl-reloc.c @@ -185,8 +185,7 @@ _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[], if (__builtin_expect (GLRO_dl_debug_mask & DL_DEBUG_RELOC, 0)) _dl_debug_printf ("\nrelocation processing: %s%s\n", - l->l_name[0] ? l->l_name : rtld_progname, - lazy ? " (lazy)" : ""); + DSO_FILENAME (l->l_name), lazy ? " (lazy)" : ""); /* DT_TEXTREL is now in level 2 and might phase out at some time. But we rewrite the DT_FLAGS entry to a DT_TEXTREL entry to make @@ -276,7 +275,7 @@ _dl_relocate_object (struct link_map *l, struct r_scope_elem *scope[], errstring = N_("%s: no PLTREL found in object %s\n"); fatal: _dl_fatal_printf (errstring, - rtld_progname ?: "<program name unknown>", + RTLD_PROGNAME, l->l_name); } diff --git a/libc/elf/dl-version.c b/libc/elf/dl-version.c index 9e2722eb9..49cc6388d 100644 --- a/libc/elf/dl-version.c +++ b/libc/elf/dl-version.c @@ -85,7 +85,7 @@ match_symbol (const char *name, Lmid_t ns, ElfW(Word) hash, const char *string, if (__builtin_expect (GLRO_dl_debug_mask & DL_DEBUG_VERSIONS, 0)) _dl_debug_printf ("\ checking for version `%s' in file %s [%lu] required by file %s [%lu]\n", - string, map->l_name[0] ? map->l_name : rtld_progname, + string, DSO_FILENAME (map->l_name), map->l_ns, name, ns); if (__builtin_expect (map->l_info[VERSYMIDX (DT_VERDEF)] == NULL, 0)) @@ -162,7 +162,7 @@ no version information available (required by ", name, ")"); name, ")"); result = 1; call_cerror: - _dl_signal_cerror (0, map->l_name[0] ? map->l_name : rtld_progname, + _dl_signal_cerror (0, DSO_FILENAME (map->l_name), N_("version lookup error"), errstring); return result; } @@ -210,7 +210,7 @@ _dl_check_map_versions (struct link_map *map, int verbose, int trace_mode) &buf[sizeof (buf) - 1], 10, 0), " of Verneed record\n"); call_error: - _dl_signal_error (errval, *map->l_name ? map->l_name : rtld_progname, + _dl_signal_error (errval, DSO_FILENAME (map->l_name), NULL, errstring); } @@ -234,8 +234,7 @@ _dl_check_map_versions (struct link_map *map, int verbose, int trace_mode) while (1) { /* Match the symbol. */ - result |= match_symbol ((*map->l_name - ? map->l_name : rtld_progname), + result |= match_symbol (DSO_FILENAME (map->l_name), map->l_ns, aux->vna_hash, strtab + aux->vna_name, needed->l_real, verbose, diff --git a/libc/elf/ldconfig.c b/libc/elf/ldconfig.c index 13f262d65..c7b9eb92f 100644 --- a/libc/elf/ldconfig.c +++ b/libc/elf/ldconfig.c @@ -174,17 +174,17 @@ is_hwcap_platform (const char *name) { int hwcap_idx = _dl_string_hwcap (name); - /* Is this a normal hwcap for the machine e.g. fpu? */ + /* Is this a normal hwcap for the machine like "fpu?" */ if (hwcap_idx != -1 && ((1 << hwcap_idx) & hwcap_mask)) return 1; - /* ... Or is it a platform pseudo-hwcap e.g. i686? */ + /* Is this a platform pseudo-hwcap like "i686?" */ hwcap_idx = _dl_string_platform (name); if (hwcap_idx != -1) return 1; - /* ... Or is this one of the extra pseudo-hwcaps that we map beyond - _DL_FIRST_EXTRA e.g. tls, or nosegneg? */ + /* Is this one of the extra pseudo-hwcaps that we map beyond + _DL_FIRST_EXTRA like "tls", or "nosegneg?" */ for (hwcap_idx = _DL_FIRST_EXTRA; hwcap_idx < 64; ++hwcap_idx) if (hwcap_extra[hwcap_idx - _DL_FIRST_EXTRA] != NULL && !strcmp (name, hwcap_extra[hwcap_idx - _DL_FIRST_EXTRA])) @@ -1270,8 +1270,10 @@ main (int argc, char **argv) add_dir (argv[i]); } - /* The last entry in hwcap_extra is reserved for the "tls" - pseudo-hwcap which indicates support for TLS. */ + /* The last entry in hwcap_extra is reserved for the "tls" pseudo-hwcap which + indicates support for TLS. This pseudo-hwcap is only used by old versions + under which TLS support was optional. The entry is no longer needed, but + must remain for compatibility. */ hwcap_extra[63 - _DL_FIRST_EXTRA] = "tls"; set_hwcap (); diff --git a/libc/elf/rtld.c b/libc/elf/rtld.c index f27771f78..8e8eafa94 100644 --- a/libc/elf/rtld.c +++ b/libc/elf/rtld.c @@ -1841,10 +1841,8 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n", if (_dl_name_match_p (GLRO(dl_trace_prelink), l)) GLRO(dl_trace_prelink_map) = l; _dl_printf ("\t%s => %s (0x%0*Zx, 0x%0*Zx)", - l->l_libname->name[0] ? l->l_libname->name - : rtld_progname ?: "<main program>", - l->l_name[0] ? l->l_name - : rtld_progname ?: "<main program>", + DSO_FILENAME (l->l_libname->name), + DSO_FILENAME (l->l_name), (int) sizeof l->l_map_start * 2, (size_t) l->l_map_start, (int) sizeof l->l_addr * 2, @@ -2001,8 +1999,7 @@ ERROR: ld.so: object '%s' cannot be loaded as audit interface: %s; ignored.\n", first = 0; } - _dl_printf ("\t%s:\n", - map->l_name[0] ? map->l_name : rtld_progname); + _dl_printf ("\t%s:\n", DSO_FILENAME (map->l_name)); while (1) { @@ -2325,7 +2322,7 @@ print_unresolved (int errcode __attribute__ ((unused)), const char *objname, const char *errstring) { if (objname[0] == '\0') - objname = rtld_progname ?: "<main program>"; + objname = RTLD_PROGNAME; _dl_error_printf ("%s (%s)\n", errstring, objname); } @@ -2335,7 +2332,7 @@ static void print_missing_version (int errcode __attribute__ ((unused)), const char *objname, const char *errstring) { - _dl_error_printf ("%s: %s: %s\n", rtld_progname ?: "<program name unknown>", + _dl_error_printf ("%s: %s: %s\n", RTLD_PROGNAME, objname, errstring); } diff --git a/libc/ports/sysdeps/aarch64/machine-gmon.h b/libc/elf/tst-null-argv-lib.c index c52a1a404..e754299dc 100644 --- a/libc/ports/sysdeps/aarch64/machine-gmon.h +++ b/libc/elf/tst-null-argv-lib.c @@ -1,5 +1,6 @@ -/* Copyright (C) 2011-2013 Free Software Foundation, Inc. - +/* Verify that program does not crash when LD_DEBUG is set and the program name + is not available. This is the library. + Copyright (C) 2013 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C Library is free software; you can redistribute it and/or @@ -13,13 +14,11 @@ Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public - License along with the GNU C Library. If not, see + License along with the GNU C Library; if not, see <http://www.gnu.org/licenses/>. */ -#define _MCOUNT_DECL(from, self) \ - void __mcount_internal (u_long from, u_long self) - -/* Call __mcount_internal with our the return PC for our caller, and - the return PC our caller will return to. Empty since we use an - assembly stub instead. */ -#define MCOUNT +void +foo (void) +{ + return; +} diff --git a/libc/elf/tst-null-argv.c b/libc/elf/tst-null-argv.c new file mode 100644 index 000000000..dc242e495 --- /dev/null +++ b/libc/elf/tst-null-argv.c @@ -0,0 +1,35 @@ +/* Verify that program does not crash when LD_DEBUG is set and the program name + is not available. + Copyright (C) 2013 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +extern void foo (void); + +int +do_test (int argc, char **argv) +{ + argv[0] = argv[1]; + argc--; + + /* This should result in a symbol lookup, causing a volley of debug output + when LD_DEBUG=symbols. */ + foo (); + + return 0; +} + +#include <test-skeleton.c> diff --git a/libc/hesiod/Makefile b/libc/hesiod/Makefile index 0e8d4139c..e4e55f593 100644 --- a/libc/hesiod/Makefile +++ b/libc/hesiod/Makefile @@ -35,12 +35,7 @@ libnss_hesiod-inhibit-o = $(filter-out .os,$(object-suffixes)) include ../Rules -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -# The Hesiod NSS modules also needs the resolver and some help from +# The Hesiod NSS module also needs the resolver and some help from # the file service. $(objpfx)libnss_hesiod.so: $(common-objpfx)resolv/libresolv.so \ - $(common-objpfx)nss/libnss_files.so \ - $(common-objpfx)libc.so \ - $(common-objpfx)libc_nonshared.a + $(common-objpfx)nss/libnss_files.so diff --git a/libc/iconvdata/extra-module.mk b/libc/iconvdata/extra-module.mk index 43f4e12fb..ecaf50762 100644 --- a/libc/iconvdata/extra-module.mk +++ b/libc/iconvdata/extra-module.mk @@ -4,16 +4,9 @@ extra-modules-left := $(strip $(filter-out $(mod),$(extra-modules-left))) extra-objs := $(extra-objs) $(patsubst %,%.os,$($(mod)-routines)) $(objpfx)$(mod).so: $(addprefix $(objpfx),$(addsuffix .os,$($(mod)-routines)))\ - $(shlib-lds) + $(shlib-lds) $(link-libc-deps) $(build-module-asneeded) -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -$(objpfx)$(mod).so: $(common-objpfx)libc.so \ - $(common-objpfx)/elf/ld.so \ - $(common-objpfx)libc_nonshared.a - ifneq (,$(extra-modules-left)) include extra-module.mk endif diff --git a/libc/intl/dcigettext.c b/libc/intl/dcigettext.c index de4ea9239..3ea0e78e1 100644 --- a/libc/intl/dcigettext.c +++ b/libc/intl/dcigettext.c @@ -652,6 +652,11 @@ DCIGETTEXT (domainname, msgid1, msgid2, plural, n, category) retval = _nl_find_msg (domain->successor[cnt], binding, msgid1, 1, &retlen); + /* Resource problems are not fatal, instead we return no + translation. */ + if (__builtin_expect (retval == (char *) -1, 0)) + goto no_translation; + if (retval != NULL) { domain = domain->successor[cnt]; @@ -957,6 +962,11 @@ _nl_find_msg (domain_file, domainbinding, msgid, convert, lengthp) nullentry = _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen); + /* Resource problems are fatal. If we continue onwards we will + only attempt to calloc a new conv_tab and fail later. */ + if (__builtin_expect (nullentry == (char *) -1, 0)) + return (char *) -1; + if (nullentry != NULL) { const char *charsetstr; @@ -1186,10 +1196,14 @@ _nl_find_msg (domain_file, domainbinding, msgid, convert, lengthp) freemem_size = INITIAL_BLOCK_SIZE; newmem = (transmem_block_t *) malloc (freemem_size); # ifdef _LIBC - /* Add the block to the list of blocks we have to free - at some point. */ - newmem->next = transmem_list; - transmem_list = newmem; + if (newmem != NULL) + { + /* Add the block to the list of blocks we have to free + at some point. */ + newmem->next = transmem_list; + transmem_list = newmem; + } + /* Fall through and return -1. */ # endif } if (__builtin_expect (newmem == NULL, 0)) diff --git a/libc/intl/loadmsgcat.c b/libc/intl/loadmsgcat.c index e4b7b385a..ac90ed101 100644 --- a/libc/intl/loadmsgcat.c +++ b/libc/intl/loadmsgcat.c @@ -1237,7 +1237,7 @@ _nl_load_domain (domain_file, domainbinding) default: /* This is an invalid revision. */ invalid: - /* This is an invalid .mo file. */ + /* This is an invalid .mo file or we ran out of resources. */ free (domain->malloced); #ifdef HAVE_MMAP if (use_mmap) @@ -1257,6 +1257,11 @@ _nl_load_domain (domain_file, domainbinding) /* Get the header entry and look for a plural specification. */ nullentry = _nl_find_msg (domain_file, domainbinding, "", 0, &nullentrylen); + if (__builtin_expect (nullentry == (char *) -1, 0)) + { + __libc_rwlock_fini (domain->conversions_lock); + goto invalid; + } EXTRACT_PLURAL_EXPRESSION (nullentry, &domain->plural, &domain->nplurals); out: diff --git a/libc/libidn/ChangeLog b/libc/libidn/ChangeLog index 619d891f2..50e5d5322 100644 --- a/libc/libidn/ChangeLog +++ b/libc/libidn/ChangeLog @@ -1,3 +1,7 @@ +2013-05-31 Joseph Myers <joseph@codesourcery.com> + + * Makefile ($(objpfx)libcidn.so): Remove dependencies on libc. + 2013-05-16 Ryan S. Arnold <rsa@linux.vnet.ibm.com> * idna.c: Add missing #include <stdint.h> due to uint64_t or uint32_t diff --git a/libc/libidn/Makefile b/libc/libidn/Makefile index b25490301..f957e3c33 100644 --- a/libc/libidn/Makefile +++ b/libc/libidn/Makefile @@ -34,5 +34,3 @@ include $(..)Makeconfig libcidn-inhibit-o = $(filter-out .os,$(object-suffixes)) include $(..)Rules - -$(objpfx)libcidn.so: $(common-objpfx)libc.so $(common-objpfx)libc_nonshared.a diff --git a/libc/libio/genops.c b/libc/libio/genops.c index 390d8d24b..e5c5d5caf 100644 --- a/libc/libio/genops.c +++ b/libc/libio/genops.c @@ -661,6 +661,10 @@ _IO_no_init (fp, flags, orientation, wd, jmp) fp->_wide_data->_wide_vtable = jmp; } + else + /* Cause predictable crash when a wide function is called on a byte + stream. */ + fp->_wide_data = (struct _IO_wide_data *) -1L; #endif fp->_freeres_list = NULL; } diff --git a/libc/locale/Makefile b/libc/locale/Makefile index e826d3054..6242bcc82 100644 --- a/libc/locale/Makefile +++ b/libc/locale/Makefile @@ -117,9 +117,3 @@ cpp-srcs-left := $(addsuffix .c,$(localedef-modules) $(localedef-aux) \ $(locale-modules) $(lib-modules)) lib := locale-programs include $(patsubst %,$(..)cppflags-iterator.mk,$(cpp-srcs-left)) - -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -$(objpfx)libBrokenLocale.so: $(common-objpfx)libc.so \ - $(common-objpfx)libc_nonshared.a diff --git a/libc/locale/programs/locarchive.c b/libc/locale/programs/locarchive.c index 1a8a69653..8475e295a 100644 --- a/libc/locale/programs/locarchive.c +++ b/libc/locale/programs/locarchive.c @@ -111,7 +111,7 @@ create_archive (const char *archivefname, struct locarhandle *ah) /* Create a temporary file in the correct directory. */ fd = mkstemp (fname); if (fd == -1) - error (EXIT_FAILURE, errno, _("cannot create temporary file")); + error (EXIT_FAILURE, errno, _("cannot create temporary file: %s"), fname); /* Create the initial content of the archive. */ head.magic = AR_MAGIC; @@ -346,7 +346,7 @@ enlarge_archive (struct locarhandle *ah, const struct locarhead *head) /* Create a temporary file in the correct directory. */ fd = mkstemp (fname); if (fd == -1) - error (EXIT_FAILURE, errno, _("cannot create temporary file")); + error (EXIT_FAILURE, errno, _("cannot create temporary file: %s"), fname); /* Copy the existing head information. */ newhead = *head; diff --git a/libc/login/Makefile b/libc/login/Makefile index 5d2434473..1fcb5d94c 100644 --- a/libc/login/Makefile +++ b/libc/login/Makefile @@ -72,8 +72,3 @@ endif $(inst_libexecdir)/pt_chown: $(objpfx)pt_chown $(+force) $(make-target-directory) -$(INSTALL_PROGRAM) -m 4755 -o root $< $@ - -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -$(objpfx)libutil.so: $(common-objpfx)libc.so $(common-objpfx)libc_nonshared.a diff --git a/libc/malloc/Makefile b/libc/malloc/Makefile index 936b9ea04..be81dd3b8 100644 --- a/libc/malloc/Makefile +++ b/libc/malloc/Makefile @@ -149,8 +149,7 @@ $(objpfx)memusage: memusage.sh # The implementation uses `dlsym' -$(objpfx)libmemusage.so: $(common-objpfx)dlfcn/libdl.so $(elfobjdir)/ld.so \ - $(common-objpfx)libc_nonshared.a +$(objpfx)libmemusage.so: $(common-objpfx)dlfcn/libdl.so # Extra dependencies $(foreach o,$(all-object-suffixes),$(objpfx)malloc$(o)): arena.c hooks.c diff --git a/libc/manual/arith.texi b/libc/manual/arith.texi index ce8844ec2..77056c3ea 100644 --- a/libc/manual/arith.texi +++ b/libc/manual/arith.texi @@ -1221,8 +1221,8 @@ These functions are used to split the number @var{value} into a normalized fraction and an exponent. If the argument @var{value} is not zero, the return value is @var{value} -times a power of two, and is always in the range 1/2 (inclusive) to 1 -(exclusive). The corresponding exponent is stored in +times a power of two, and its magnitude is always in the range 1/2 +(inclusive) to 1 (exclusive). The corresponding exponent is stored in @code{*@var{exponent}}; the return value multiplied by 2 raised to this exponent equals the original number @var{value}. diff --git a/libc/manual/errno.texi b/libc/manual/errno.texi index 2a3c004b2..6c9fa865d 100644 --- a/libc/manual/errno.texi +++ b/libc/manual/errno.texi @@ -739,13 +739,14 @@ The user's disk quota was exceeded. @end deftypevr @comment errno.h -@comment BSD: Stale NFS file handle +@comment BSD: Stale file handle @deftypevr Macro int ESTALE @comment errno 70 @c DO NOT REMOVE -Stale NFS file handle. This indicates an internal confusion in the NFS -system which is due to file system rearrangements on the server host. -Repairing this condition usually requires unmounting and remounting -the NFS file system on the local host. +Stale file handle. This indicates an internal confusion in the +file system which is due to file system rearrangements on the server host +for NFS file systems or corruption in other file systems. +Repairing this condition usually requires unmounting, possibly repairing +and remounting the file system. @end deftypevr @comment errno.h diff --git a/libc/manual/platform.texi b/libc/manual/platform.texi index e387ff4cc..99f46755a 100644 --- a/libc/manual/platform.texi +++ b/libc/manual/platform.texi @@ -34,3 +34,48 @@ This frequency is not related to the processor clock or the bus clock. It is also possible that this frequency is not constant. More information is available in @cite{Power ISA 2.06b - Book II - Section 5.2}. @end deftypefun + +The following functions provide hints about the usage of resources that are +shared with other processors. They can be used, for example, if a program +waiting on a lock intends to divert the shared resources to be used by other +processors. More information is available in @cite{Power ISA 2.06b - Book II - +Section 3.2}. + +@deftypefun {void} __ppc_yield (void) +Provide a hint that performance will probably be improved if shared resources +dedicated to the executing processor are released for use by other processors. +@end deftypefun + +@deftypefun {void} __ppc_mdoio (void) +Provide a hint that performance will probably be improved if shared resources +dedicated to the executing processor are released until all outstanding storage +accesses to caching-inhibited storage have been completed. +@end deftypefun + +@deftypefun {void} __ppc_mdoom (void) +Provide a hint that performance will probably be improved if shared resources +dedicated to the executing processor are released until all outstanding storage +accesses to cacheable storage for which the data is not in the cache have been +completed. +@end deftypefun + +@deftypefun {void} __ppc_set_ppr_med (void) +Set the Program Priority Register to medium value (default). + +The @dfn{Program Priority Register} (PPR) is a 64-bit register that controls +the program's priority. By adjusting the PPR value the programmer may +improve system throughput by causing the system resources to be used +more efficiently, especially in contention situations. +The three unprivileged states available are covered by the functions +@code{__ppc_set_ppr_med} (medium -- default), @code{__ppc_set_ppc_low} (low) +and @code{__ppc_set_ppc_med_low} (medium low). More information +available in @cite{Power ISA 2.06b - Book II - Section 3.1}. +@end deftypefun + +@deftypefun {void} __ppc_set_ppr_low (void) +Set the Program Priority Register to low value. +@end deftypefun + +@deftypefun {void} __ppc_set_ppr_med_low (void) +Set the Program Priority Register to medium low value. +@end deftypefun diff --git a/libc/math/Makefile b/libc/math/Makefile index e7d85028d..c880f38da 100644 --- a/libc/math/Makefile +++ b/libc/math/Makefile @@ -231,8 +231,3 @@ gmp-objs = $(patsubst %,$(common-objpfx)stdlib/%.o,\ $(objpfx)atest-exp: $(gmp-objs) $(objpfx)atest-sincos: $(gmp-objs) $(objpfx)atest-exp2: $(gmp-objs) - -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -$(objpfx)libm.so: $(common-objpfx)libc.so $(common-objpfx)libc_nonshared.a diff --git a/libc/math/README.libm-test b/libc/math/README.libm-test index cea039207..a083a6d62 100644 --- a/libc/math/README.libm-test +++ b/libc/math/README.libm-test @@ -103,8 +103,3 @@ The accepted parameter types are: - "L" for long long int. - "F" for the address of a FLOAT (only as input parameter) - "I" for the address of an int (only as input parameter) - -Some functions need special handling. For example gamma sets the -global variable signgam and frexp takes an argument to &int. This -special treatment is coded in "gen-libm-test.pl" and used while -parsing "libm-test.inc". diff --git a/libc/math/complex.h b/libc/math/complex.h index 5bdcc93f9..82c7962fe 100644 --- a/libc/math/complex.h +++ b/libc/math/complex.h @@ -52,9 +52,7 @@ __BEGIN_DECLS /* Macros to expand into expression of specified complex type. */ # define CMPLX(x, y) __builtin_complex ((double) (x), (double) (y)) # define CMPLXF(x, y) __builtin_complex ((float) (x), (float) (y)) -# ifndef __NO_LONG_DOUBLE_MATH -# define CMPLXL(x, y) __builtin_complex ((long double) (x), (long double) (y)) -# endif +# define CMPLXL(x, y) __builtin_complex ((long double) (x), (long double) (y)) #endif /* The file <bits/cmathcalls.h> contains the prototypes for all the diff --git a/libc/math/gen-libm-test.pl b/libc/math/gen-libm-test.pl index 2217948ab..c2d10d35e 100755 --- a/libc/math/gen-libm-test.pl +++ b/libc/math/gen-libm-test.pl @@ -41,8 +41,6 @@ use strict; use vars qw ($input $output); use vars qw (%results); -use vars qw (@tests @functions); -use vars qw ($count); use vars qw (%beautify @all_floats); use vars qw ($output_dir $ulps_file); @@ -103,8 +101,6 @@ $output_dir = $opt_o if ($opt_o); $input = "libm-test.inc"; $output = "${output_dir}libm-test.c"; -$count = 0; - &parse_ulps ($ulps_file); &generate_testfile ($input, $output) unless ($opt_n); &output_ulps ("${output_dir}libm-test-ulps.h", $ulps_file) unless ($opt_n); @@ -148,133 +144,68 @@ sub build_complex_beautify { return $str1; } -# Return name of a variable -sub get_variable { - my ($number) = @_; - - return "x" if ($number == 1); - return "y" if ($number == 2); - return "z" if ($number == 3); - # return x1,x2,... - $number =-3; - return "x$number"; -} - -# Add a new test to internal data structures and fill in the -# ulps and exception information for the C line. -sub new_test { - my ($test, $exception, $show_exception) = @_; - my $rest; - - # Add ulp. - if (exists $results{$test}{'has_ulps'}) { - $rest = ", DELTA$count"; +# Return the text to put in an initializer for a test's exception +# information. +sub show_exceptions { + my ($exception) = @_; + if (defined $exception) { + return ", $exception"; } else { - $rest = ', 0'; + return ', 0'; } - if ($show_exception) { - if (defined $exception) { - $rest .= ", $exception"; - } else { - $rest .= ', 0'; - } - } - # We must increment here to keep @tests and count in sync - push @tests, $test; - ++$count; - return $rest; -} - -# Treat some functions especially. -# Currently only sincos needs extra treatment. -sub special_functions { - my ($file, $args) = @_; - my (@args, $str, $test, $cline); - - @args = split /,\s*/, $args; - - unless ($args[0] =~ /sincos/) { - die ("Don't know how to handle $args[0] extra."); - } - $cline = " { $args[1]"; - - $str = 'sincos (' . &beautify ($args[1]) . ', &sin_res, &cos_res)'; - # handle sin - $test = $str . ' puts ' . &beautify ($args[2]) . ' in sin_res'; - - $cline .= ", \"$test\", $args[2]"; - $cline .= &new_test ($test, $args[4], 0); - - # handle cos - $test = $str . ' puts ' . &beautify ($args[3]) . ' in cos_res'; - $cline .= ", \"$test\", $args[3]"; - $cline .= &new_test ($test, $args[4], 1); - $cline .= " },\n"; - print $file $cline; } # Parse the arguments to TEST_x_y sub parse_args { - my ($file, $descr, $fct, $args) = @_; - my (@args, $str, $descr_args, $descr_res, @descr); + my ($file, $descr, $args) = @_; + my (@args, $descr_args, $descr_res, @descr); my ($current_arg, $cline, $i); my (@special); - my ($extra_var, $call); + my ($call_args); - if ($descr eq 'extra') { - &special_functions ($file, $args); - return; - } ($descr_args, $descr_res) = split /_/,$descr, 2; @args = split /,\s*/, $args; - $call = "$fct ("; + $call_args = ""; # Generate first the string that's shown to the user $current_arg = 1; - $extra_var = 0; @descr = split //,$descr_args; for ($i = 0; $i <= $#descr; $i++) { - if ($i >= 1) { - $call .= ', '; + my $comma = ""; + if ($current_arg > 1) { + $comma = ', '; } # FLOAT, int, long int, long long int if ($descr[$i] =~ /f|i|l|L/) { - $call .= &beautify ($args[$current_arg]); + $call_args .= $comma . &beautify ($args[$current_arg]); ++$current_arg; next; } - # &FLOAT, &int - argument is added here + # &FLOAT, &int - simplify call by not showing argument. if ($descr[$i] =~ /F|I/) { - ++$extra_var; - $call .= '&' . &get_variable ($extra_var); next; } # complex if ($descr[$i] eq 'c') { - $call .= &build_complex_beautify ($args[$current_arg], $args[$current_arg+1]); + $call_args .= $comma . &build_complex_beautify ($args[$current_arg], $args[$current_arg+1]); $current_arg += 2; next; } die ("$descr[$i] is unknown"); } - $call .= ')'; - $str = "$call == "; # Result @descr = split //,$descr_res; foreach (@descr) { if ($_ =~ /f|i|l|L/) { - $str .= &beautify ($args[$current_arg]); ++$current_arg; } elsif ($_ eq 'c') { - $str .= &build_complex_beautify ($args[$current_arg], $args[$current_arg+1]); $current_arg += 2; } elsif ($_ eq 'b') { # boolean - $str .= ($args[$current_arg] == 0) ? "false" : "true"; ++$current_arg; } elsif ($_ eq '1') { ++$current_arg; @@ -296,8 +227,7 @@ sub parse_args { # Put the C program line together # Reset some variables to start again $current_arg = 1; - $extra_var = 0; - $cline = "{ \"$str\""; + $cline = "{ \"$call_args\""; @descr = split //,$descr_args; for ($i=0; $i <= $#descr; $i++) { # FLOAT, int, long int, long long int @@ -317,89 +247,35 @@ sub parse_args { next; } } - $cline .= ", "; @descr = split //,$descr_res; foreach (@descr) { if ($_ =~ /b|f|i|l|L/ ) { - $cline .= $args[$current_arg]; + $cline .= ", $args[$current_arg]"; $current_arg++; } elsif ($_ eq 'c') { - $cline .= "$args[$current_arg], $args[$current_arg+1]"; + $cline .= ", $args[$current_arg], $args[$current_arg+1]"; $current_arg += 2; } elsif ($_ eq '1') { push @special, $args[$current_arg]; ++$current_arg; } } - # Add ulp. - $cline .= &new_test ($str, ($current_arg <= $#args) ? $args[$current_arg] : undef, 1); + # Add exceptions. + $cline .= show_exceptions (($current_arg <= $#args) + ? $args[$current_arg] + : undef); # special treatment for some functions - if ($args[0] eq 'frexp') { - if (defined $special[0]) { - my ($extra_expected) = $special[0]; - my ($run_extra) = ($extra_expected ne "IGNORE" ? 1 : 0); - my ($str) = "$call sets x to $extra_expected"; - if (!$run_extra) { - $str = ""; - $extra_expected = "0"; - } - $cline .= ", \"$str\", $run_extra, $extra_expected"; - if ($run_extra) { - $cline .= &new_test ($str, undef, 0); - } else { - $cline .= ", 0"; - } - } - } elsif ($args[0] eq 'gamma' || $args[0] eq 'lgamma') { - if (defined $special[0]) { - my ($extra_expected) = $special[0]; - my ($run_extra) = ($extra_expected ne "IGNORE" ? 1 : 0); - my ($str) = "$call sets signgam to $extra_expected"; - if (!$run_extra) { - $str = ""; - $extra_expected = "0"; - } - $cline .= ", \"$str\", $run_extra, $extra_expected"; - if ($run_extra) { - $cline .= &new_test ($str, undef, 0); - } else { - $cline .= ", 0"; - } - } - } elsif ($args[0] eq 'modf') { - if (defined $special[0]) { - my ($extra_expected) = $special[0]; - my ($run_extra) = ($extra_expected ne "IGNORE" ? 1 : 0); - my ($str) = "$call sets x to $extra_expected"; - if (!$run_extra) { - $str = ""; - $extra_expected = "0"; - } - $cline .= ", \"$str\", $run_extra, $extra_expected"; - if ($run_extra) { - $cline .= &new_test ($str, undef, 0); - } else { - $cline .= ", 0"; - } - } - } elsif ($args[0] eq 'remquo') { - if (defined $special[0]) { - my ($extra_expected) = $special[0]; - my ($run_extra) = ($extra_expected ne "IGNORE" ? 1 : 0); - my ($str) = "$call sets x to $extra_expected"; - if (!$run_extra) { - $str = ""; - $extra_expected = "0"; - } - $cline .= ", \"$str\", $run_extra, $extra_expected"; - if ($run_extra) { - $cline .= &new_test ($str, undef, 0); - } else { - $cline .= ", 0"; - } + $i = 0; + foreach (@special) { + ++$i; + my ($extra_expected) = $_; + my ($run_extra) = ($extra_expected ne "IGNORE" ? 1 : 0); + if (!$run_extra) { + $extra_expected = "0"; } + $cline .= ", $run_extra, $extra_expected"; } print $file " $cline },\n"; } @@ -408,7 +284,7 @@ sub parse_args { sub generate_testfile { my ($input, $output) = @_; my ($lasttext); - my (@args, $i, $str, $thisfct); + my (@args, $i); open INPUT, $input or die ("Can't open $input: $!"); open OUTPUT, ">$output" or die ("Can't open $output: $!"); @@ -421,47 +297,7 @@ sub generate_testfile { my ($descr, $args); chop; ($descr, $args) = ($_ =~ /TEST_(\w+)\s*\((.*)\)/); - &parse_args (\*OUTPUT, $descr, $thisfct, $args); - next; - } - # START_DATA (function) - if (/START_DATA/) { - ($thisfct) = ($_ =~ /START_DATA\s*\((.*)\)/); - next; - } - # START (function) - if (/START/) { - ($thisfct) = ($_ =~ /START\s*\((.*)\)/); - print OUTPUT " init_max_error ();\n"; - next; - } - # END_DATA (function) - if (/END_DATA/) { - next; - } - # END (function) - if (/END/) { - my ($fct, $line, $type); - if (/complex/) { - s/,\s*complex\s*//; - $type = 'complex'; - } else { - $type = 'normal'; - } - ($fct) = ($_ =~ /END\s*\((.*)\)/); - 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'; - } - $line .= ");\n"; - print OUTPUT $line; - push @functions, $fct; + &parse_args (\*OUTPUT, $descr, $args); next; } print OUTPUT; @@ -620,37 +456,15 @@ sub print_ulps_file { sub get_ulps { my ($test, $type, $float) = @_; - if ($type eq 'complex') { - my ($res); - # Return 0 instead of BUILD_COMPLEX_ULP (0,0) - if (!exists $results{$test}{'real'}{'ulp'}{$float} && - !exists $results{$test}{'imag'}{'ulp'}{$float}) { - return "0"; - } - $res = 'BUILD_COMPLEX_ULP ('; - $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"); + return (exists $results{$test}{$type}{'ulp'}{$float} + ? $results{$test}{$type}{'ulp'}{$float} : "0"); } -# Output the defines for a single test -sub output_test { - my ($file, $test, $name) = @_; +# Return the ulps value for a single test. +sub get_all_ulps_for_test { + my ($test, $type) = @_; my ($ldouble, $double, $float, $ildouble, $idouble, $ifloat); - my ($type); - # Do we have ulps? - 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"); @@ -659,14 +473,17 @@ sub output_test { $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"; + return "CHOOSE ($ldouble, $double, $float, $ildouble, $idouble, $ifloat)"; + } else { + die "get_all_ulps_for_test called for \"$test\" with no ulps\n"; } } # Print include file sub output_ulps { my ($file, $ulps_filename) = @_; - my ($i, $fct); + my ($i, $fct, $type, $ulp, $ulp_real, $ulp_imag); + my (%test_ulps, %func_ulps, %func_real_ulps, %func_imag_ulps); open ULP, ">$file" or die ("Can't open $file: $!"); @@ -674,14 +491,56 @@ sub output_ulps { print ULP " from $ulps_filename with gen-libm-test.pl.\n"; print ULP " Don't change it - change instead the master files. */\n\n"; + foreach $fct (keys %results) { + $type = $results{$fct}{'type'}; + if ($type eq 'normal') { + $ulp = get_all_ulps_for_test ($fct, 'normal'); + } elsif ($type eq 'complex') { + $ulp_real = get_all_ulps_for_test ($fct, 'real'); + $ulp_imag = get_all_ulps_for_test ($fct, 'imag'); + } else { + die "unknown results ($fct) type $type\n"; + } + if ($results{$fct}{'kind'} eq 'fct') { + if ($type eq 'normal') { + $func_ulps{$fct} = $ulp; + } else { + $func_real_ulps{$fct} = $ulp_real; + $func_imag_ulps{$fct} = $ulp_imag; + } + } elsif ($results{$fct}{'kind'} eq 'test') { + if ($type eq 'normal') { + $test_ulps{$fct} = $ulp; + } else { + $test_ulps{"Real part of: $fct"} = $ulp_real; + $test_ulps{"Imaginary part of: $fct"} = $ulp_imag; + } + } else { + die "unknown results ($fct) kind $results{$fct}{'kind'}\n"; + } + } print ULP "\n/* Maximal error of functions. */\n"; - foreach $fct (@functions) { - output_test (\*ULP, $fct, $fct); + print ULP "static const struct ulp_data func_ulps[] =\n {\n"; + foreach $fct (sort keys %func_ulps) { + print ULP " { \"$fct\", $func_ulps{$fct} },\n"; + } + print ULP " };\n"; + print ULP "static const struct ulp_data func_real_ulps[] =\n {\n"; + foreach $fct (sort keys %func_real_ulps) { + print ULP " { \"$fct\", $func_real_ulps{$fct} },\n"; + } + print ULP " };\n"; + print ULP "static const struct ulp_data func_imag_ulps[] =\n {\n"; + foreach $fct (sort keys %func_imag_ulps) { + print ULP " { \"$fct\", $func_imag_ulps{$fct} },\n"; } + print ULP " };\n"; print ULP "\n/* Error of single function calls. */\n"; - for ($i = 0; $i < $count; $i++) { - output_test (\*ULP, $tests[$i], $i); + print ULP "static const struct ulp_data test_ulps[] =\n {\n"; + foreach $fct (sort keys %test_ulps) { + print ULP " { \"$fct\", $test_ulps{$fct} },\n"; } + print ULP " };\n"; close ULP; } diff --git a/libc/math/libm-test.inc b/libc/math/libm-test.inc index 41344bc86..6870d96d5 100644 --- a/libc/math/libm-test.inc +++ b/libc/math/libm-test.inc @@ -39,7 +39,7 @@ /* This testsuite has currently tests for: acos, acosh, asin, asinh, atan, atan2, atanh, - cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1, + cbrt, ceil, copysign, cos, cosh, drem, erf, erfc, exp, exp10, exp2, expm1, fabs, fdim, finite, floor, fma, fmax, fmin, fmod, fpclassify, frexp, gamma, hypot, ilogb, isfinite, isinf, isnan, isnormal, issignaling, @@ -47,7 +47,7 @@ j0, j1, jn, ldexp, lgamma, log, log10, log1p, log2, logb, modf, nearbyint, nextafter, nexttoward, - pow, remainder, remquo, rint, lrint, llrint, + pow, pow10, remainder, remquo, rint, lrint, llrint, round, lround, llround, scalb, scalbn, scalbln, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc, y0, y1, yn, significand @@ -58,10 +58,8 @@ csin, csinh, csqrt, ctan, ctanh. At the moment the following functions and macros aren't tested: - drem (alias for remainder), lgamma_r, - nan, - pow10 (alias for exp10). + nan. Parameter handling is primitive in the moment: --verbose=[0..3] for different levels of output: @@ -115,7 +113,6 @@ # define _GNU_SOURCE #endif -#include "libm-test-ulps.h" #include <complex.h> #include <math.h> #include <float.h> @@ -129,6 +126,18 @@ #include <argp.h> #include <tininess.h> +/* Structure for ulp data for a test, a function, or the real or + imaginary part of a function. */ +struct ulp_data +{ + const char *name; + FLOAT max_ulp; +}; + +/* This header defines test_ulps, func_ulps, func_real_ulps and + func_imag_ulps arrays. */ +#include "libm-test-ulps.h" + /* Allow platforms without all rounding modes to test properly, assuming they provide an __FE_UNDEFINED in <bits/fenv.h> which causes fesetround() to return failure. */ @@ -257,10 +266,69 @@ static FLOAT max_error, real_max_error, imag_max_error; __real__ __retval = (real); \ __imag__ __retval = (imag); \ __retval; }) -#define BUILD_COMPLEX_ULP(real, imag) ((real) + I * (imag)) #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)) +#define MIN_EXP CHOOSE ((LDBL_MIN_EXP-1), (DBL_MIN_EXP-1), (FLT_MIN_EXP-1), \ + (LDBL_MIN_EXP-1), (DBL_MIN_EXP-1), (FLT_MIN_EXP-1)) + +/* Compare KEY (a string, with the name of a test or a function) with + ULP (a pointer to a struct ulp_data structure), returning a value + less than, equal to or greater than zero for use in bsearch. */ + +static int +compare_ulp_data (const void *key, const void *ulp) +{ + const char *keystr = key; + const struct ulp_data *ulpdat = ulp; + return strcmp (keystr, ulpdat->name); +} + +/* Return the ulps for NAME in array DATA with NMEMB elements, or 0 if + no ulps listed. */ + +static FLOAT +find_ulps (const char *name, const struct ulp_data *data, size_t nmemb) +{ + const struct ulp_data *entry = bsearch (name, data, nmemb, sizeof (*data), + compare_ulp_data); + if (entry == NULL) + return 0; + else + return entry->max_ulp; +} + +/* Return the ulps for test NAME. */ + +static FLOAT +find_test_ulps (const char *name) +{ + return find_ulps (name, test_ulps, + sizeof (test_ulps) / sizeof (test_ulps[0])); +} + +/* Return the ulps for real function NAME. */ + +static FLOAT +find_function_ulps (const char *name) +{ + return find_ulps (name, func_ulps, + sizeof (func_ulps) / sizeof (func_ulps[0])); +} + +/* Return the ulps for complex function NAME. */ + +static __complex__ FLOAT +find_complex_function_ulps (const char *name) +{ + FLOAT ulp_real = find_ulps (name, func_real_ulps, + (sizeof (func_real_ulps) + / sizeof (func_real_ulps[0]))); + FLOAT ulp_imag = find_ulps (name, func_imag_ulps, + (sizeof (func_imag_ulps) + / sizeof (func_imag_ulps[0]))); + return BUILD_COMPLEX (ulp_real, ulp_imag); +} static void init_max_error (void) @@ -407,8 +475,9 @@ fpstack_test (const char *test_name) static void -print_max_error (const char *func_name, FLOAT allowed) +print_max_error (const char *func_name) { + FLOAT allowed = find_function_ulps (func_name); int ok = 0; if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp)) @@ -432,8 +501,9 @@ print_max_error (const char *func_name, FLOAT allowed) static void -print_complex_max_error (const char *func_name, __complex__ FLOAT allowed) +print_complex_max_error (const char *func_name) { + __complex__ FLOAT allowed = find_complex_function_ulps (func_name); int ok = 0; if ((real_max_error == 0 && imag_max_error == 0) @@ -587,19 +657,58 @@ test_errno (const char *test_name, int errno_value, int exceptions) test_single_errno (test_name, errno_value, ERANGE, "ERANGE"); } +/* Returns the number of ulps that GIVEN is away from EXPECTED. */ +#define ULPDIFF(given, expected) \ + (FUNC(fabs) ((given) - (expected)) / ulp (expected)) + +/* Returns the size of an ulp for VALUE. */ +static FLOAT +ulp (FLOAT value) +{ + FLOAT ulp; + + switch (fpclassify (value)) + { + case FP_ZERO: + /* We compute the distance to the next FP which is the same as the + value of the smallest subnormal number. Previously we used + 2^(-MANT_DIG) which is too large a value to be useful. Note that we + can't use ilogb(0), since that isn't a valid thing to do. As a point + of comparison Java's ulp returns the next normal value e.g. + 2^(1 - MAX_EXP) for ulp(0), but that is not what we want for + glibc. */ + /* Fall through... */ + case FP_SUBNORMAL: + /* The next closest subnormal value is a constant distance away. */ + ulp = FUNC(ldexp) (1.0, MIN_EXP - MANT_DIG); + break; + + case FP_NORMAL: + ulp = FUNC(ldexp) (1.0, FUNC(ilogb) (value) - MANT_DIG); + break; + + default: + /* It should never happen. */ + abort (); + break; + } + return ulp; +} + static void check_float_internal (const char *test_name, FLOAT computed, FLOAT expected, - FLOAT max_ulp, int exceptions, + int exceptions, FLOAT *curr_max_error) { int ok = 0; int print_diff = 0; FLOAT diff = 0; - FLOAT ulp = 0; + FLOAT ulps = 0; int errno_value = errno; test_exceptions (test_name, exceptions); test_errno (test_name, errno_value, exceptions); + FLOAT max_ulp = find_test_ulps (test_name); if (issignaling (computed) && issignaling (expected)) ok = 1; else if (issignaling (computed) || issignaling (expected)) @@ -625,37 +734,19 @@ check_float_internal (const char *test_name, FLOAT computed, FLOAT expected, else { diff = FUNC(fabs) (computed - expected); - switch (fpclassify (expected)) - { - case FP_ZERO: - /* ilogb (0) isn't allowed. */ - ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG); - break; - case FP_NORMAL: - ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG); - break; - case FP_SUBNORMAL: - /* 1ulp for a subnormal value, shifted by MANT_DIG, is the - least normal value. */ - ulp = (FUNC(ldexp) (diff, MANT_DIG) / min_value); - break; - default: - /* It should never happen. */ - abort (); - break; - } - set_max_error (ulp, curr_max_error); + ulps = ULPDIFF (computed, expected); + set_max_error (ulps, curr_max_error); print_diff = 1; if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0 && computed == 0.0 && expected == 0.0 && signbit(computed) != signbit (expected)) ok = 0; - else if (ulp <= 0.5 || (ulp <= max_ulp && !ignore_max_ulp)) + else if (ulps <= 0.5 || (ulps <= max_ulp && !ignore_max_ulp)) ok = 1; else { ok = 0; - print_ulps (test_name, ulp); + print_ulps (test_name, ulps); } } @@ -673,7 +764,7 @@ check_float_internal (const char *test_name, FLOAT computed, FLOAT expected, { printf (" difference: % .20" PRINTF_EXPR " % .20" PRINTF_XEXPR "\n", diff, diff); - printf (" ulp : % .4" PRINTF_NEXPR "\n", ulp); + printf (" ulp : % .4" PRINTF_NEXPR "\n", ulps); printf (" max.ulp : % .4" PRINTF_NEXPR "\n", max_ulp); } } @@ -686,9 +777,9 @@ check_float_internal (const char *test_name, FLOAT computed, FLOAT expected, static void check_float (const char *test_name, FLOAT computed, FLOAT expected, - FLOAT max_ulp, int exceptions) + int exceptions) { - check_float_internal (test_name, computed, expected, max_ulp, + check_float_internal (test_name, computed, expected, exceptions, &max_error); } @@ -696,10 +787,9 @@ check_float (const char *test_name, FLOAT computed, FLOAT expected, static void check_complex (const char *test_name, __complex__ FLOAT computed, __complex__ FLOAT expected, - __complex__ FLOAT max_ulp, int exception) { - FLOAT part_comp, part_exp, part_max_ulp; + FLOAT part_comp, part_exp; char *str; if (asprintf (&str, "Real part of: %s", test_name) == -1) @@ -707,9 +797,8 @@ check_complex (const char *test_name, __complex__ FLOAT computed, part_comp = __real__ computed; part_exp = __real__ expected; - part_max_ulp = __real__ max_ulp; - check_float_internal (str, part_comp, part_exp, part_max_ulp, + check_float_internal (str, part_comp, part_exp, exception, &real_max_error); free (str); @@ -718,11 +807,10 @@ check_complex (const char *test_name, __complex__ FLOAT computed, part_comp = __imag__ computed; part_exp = __imag__ expected; - part_max_ulp = __imag__ max_ulp; /* Don't check again for exceptions or errno, just pass through the zero/inf sign test. */ - check_float_internal (str, part_comp, part_exp, part_max_ulp, + check_float_internal (str, part_comp, part_exp, exception & IGNORE_ZERO_INF_SIGN, &imag_max_error); free (str); @@ -731,7 +819,7 @@ check_complex (const char *test_name, __complex__ FLOAT computed, /* Check that computed and expected values are equal (int values). */ static void -check_int (const char *test_name, int computed, int expected, int max_ulp, +check_int (const char *test_name, int computed, int expected, int exceptions) { int ok = 0; @@ -762,7 +850,7 @@ check_int (const char *test_name, int computed, int expected, int max_ulp, /* Check that computed and expected values are equal (long int values). */ static void check_long (const char *test_name, long int computed, long int expected, - long int max_ulp, int exceptions) + int exceptions) { int ok = 0; int errno_value = errno; @@ -792,7 +880,7 @@ check_long (const char *test_name, long int computed, long int expected, /* Check that computed value is true/false. */ static void check_bool (const char *test_name, int computed, int expected, - long int max_ulp, int exceptions) + int exceptions) { int ok = 0; int errno_value = errno; @@ -823,7 +911,6 @@ check_bool (const char *test_name, int computed, int expected, static void check_longlong (const char *test_name, long long int computed, long long int expected, - long long int max_ulp, int exceptions) { int ok = 0; @@ -853,169 +940,145 @@ check_longlong (const char *test_name, long long int computed, /* Structures for each kind of test. */ struct test_f_f_data { - const char *test_name; + const char *arg_str; FLOAT arg; FLOAT expected; - FLOAT max_ulp; int exceptions; }; struct test_ff_f_data { - const char *test_name; + const char *arg_str; FLOAT arg1, arg2; FLOAT expected; - FLOAT max_ulp; int exceptions; }; struct test_ff_f_data_nexttoward { - const char *test_name; + const char *arg_str; FLOAT arg1; long double arg2; FLOAT expected; - FLOAT max_ulp; int exceptions; }; struct test_fi_f_data { - const char *test_name; + const char *arg_str; FLOAT arg1; int arg2; FLOAT expected; - FLOAT max_ulp; int exceptions; }; struct test_fl_f_data { - const char *test_name; + const char *arg_str; FLOAT arg1; long int arg2; FLOAT expected; - FLOAT max_ulp; int exceptions; }; struct test_if_f_data { - const char *test_name; + const char *arg_str; int arg1; FLOAT arg2; FLOAT expected; - FLOAT max_ulp; int exceptions; }; struct test_fff_f_data { - const char *test_name; + const char *arg_str; FLOAT arg1, arg2, arg3; FLOAT expected; - FLOAT max_ulp; int exceptions; }; struct test_c_f_data { - const char *test_name; + const char *arg_str; FLOAT argr, argc; FLOAT expected; - FLOAT max_ulp; int exceptions; }; /* Used for both RUN_TEST_LOOP_f_f1 and RUN_TEST_LOOP_fI_f1. */ struct test_f_f1_data { - const char *test_name; + const char *arg_str; FLOAT arg; FLOAT expected; - FLOAT max_ulp; int exceptions; - const char *extra_name; int extra_test; int extra_expected; - int extra_ulp; }; struct test_fF_f1_data { - const char *test_name; + const char *arg_str; FLOAT arg; FLOAT expected; - FLOAT max_ulp; int exceptions; - const char *extra_name; int extra_test; FLOAT extra_expected; - FLOAT extra_ulp; }; struct test_ffI_f1_data { - const char *test_name; + const char *arg_str; FLOAT arg1, arg2; FLOAT expected; - FLOAT max_ulp; int exceptions; - const char *extra_name; int extra_test; int extra_expected; - int extra_ulp; }; struct test_c_c_data { - const char *test_name; + const char *arg_str; FLOAT argr, argc; FLOAT expr, expc; - __complex__ FLOAT max_ulp; int exceptions; }; struct test_cc_c_data { - const char *test_name; + const char *arg_str; FLOAT arg1r, arg1c, arg2r, arg2c; FLOAT expr, expc; - __complex__ FLOAT max_ulp; int exceptions; }; /* Used for all of RUN_TEST_LOOP_f_i, RUN_TEST_LOOP_f_i_tg, RUN_TEST_LOOP_f_b and RUN_TEST_LOOP_f_b_tg. */ struct test_f_i_data { - const char *test_name; + const char *arg_str; FLOAT arg; int expected; - int max_ulp; int exceptions; }; struct test_ff_i_data { - const char *test_name; + const char *arg_str; FLOAT arg1, arg2; int expected; - int max_ulp; int exceptions; }; struct test_f_l_data { - const char *test_name; + const char *arg_str; FLOAT arg; long int expected; - long int max_ulp; int exceptions; }; struct test_f_L_data { - const char *test_name; + const char *arg_str; FLOAT arg; long long int expected; - long long int max_ulp; int exceptions; }; -struct test_sincos_data +struct test_fFF_11_data { + const char *arg_str; FLOAT arg; - const char *test_name_sin; - FLOAT expected_sin; - FLOAT max_ulp_sin; - const char *test_name_cos; - FLOAT expected_cos; - FLOAT max_ulp_cos; int exceptions; + int extra1_test; + FLOAT extra1_expected; + int extra2_test; + FLOAT extra2_expected; }; /* Set the rounding mode, or restore the saved value. */ @@ -1042,29 +1105,61 @@ struct test_sincos_data #define ROUND_RESTORE_FE_UPWARD \ fesetround (save_round_mode) +/* Common setup for an individual test. */ +#define COMMON_TEST_SETUP(ARG_STR) \ + char *test_name; \ + if (asprintf (&test_name, "%s (%s)", this_func, (ARG_STR)) == -1) \ + abort () + +/* Setup for a test with an extra output. */ +#define EXTRA_OUTPUT_TEST_SETUP(ARG_STR, N) \ + char *extra##N##_name; \ + if (asprintf (&extra##N##_name, "%s (%s) extra output " #N, \ + this_func, (ARG_STR)) == -1) \ + abort () + +/* Common cleanup after an individual test. */ +#define COMMON_TEST_CLEANUP \ + free (test_name) + +/* Cleanup for a test with an extra output. */ +#define EXTRA_OUTPUT_TEST_CLEANUP(N) \ + free (extra##N##_name) + /* Run an individual test, including any required setup and checking of results, or loop over all tests in an array. */ -#define RUN_TEST_f_f(TEST_NAME, FUNC_NAME, ARG, EXPECTED, \ - MAX_ULP, EXCEPTIONS) \ - check_float (TEST_NAME, FUNC (FUNC_NAME) (ARG), EXPECTED, \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_f_f(ARG_STR, FUNC_NAME, ARG, EXPECTED, \ + EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_float (test_name, FUNC (FUNC_NAME) (ARG), EXPECTED, \ + EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_f_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_f_f ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions); \ + RUN_TEST_f_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_2_f(TEST_NAME, FUNC_NAME, ARG1, ARG2, EXPECTED, \ - MAX_ULP, EXCEPTIONS) \ - check_float (TEST_NAME, FUNC (FUNC_NAME) (ARG1, ARG2), EXPECTED, \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_2_f(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \ + EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_float (test_name, FUNC (FUNC_NAME) (ARG1, ARG2), EXPECTED, \ + EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_2_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_2_f ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg1, \ + RUN_TEST_2_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \ (ARRAY)[i].arg2, (ARRAY)[i].expected, \ - (ARRAY)[i].max_ulp, (ARRAY)[i].exceptions); \ + (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE #define RUN_TEST_ff_f RUN_TEST_2_f #define RUN_TEST_LOOP_ff_f RUN_TEST_LOOP_2_f @@ -1074,258 +1169,326 @@ struct test_sincos_data #define RUN_TEST_LOOP_fl_f RUN_TEST_LOOP_2_f #define RUN_TEST_if_f RUN_TEST_2_f #define RUN_TEST_LOOP_if_f RUN_TEST_LOOP_2_f -#define RUN_TEST_fff_f(TEST_NAME, FUNC_NAME, ARG1, ARG2, ARG3, \ - EXPECTED, MAX_ULP, EXCEPTIONS) \ - check_float (TEST_NAME, FUNC (FUNC_NAME) (ARG1, ARG2, ARG3), \ - EXPECTED, MAX_ULP, EXCEPTIONS) +#define RUN_TEST_fff_f(ARG_STR, FUNC_NAME, ARG1, ARG2, ARG3, \ + EXPECTED, EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_float (test_name, FUNC (FUNC_NAME) (ARG1, ARG2, ARG3), \ + EXPECTED, EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_fff_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_fff_f ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg1, \ + RUN_TEST_fff_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1, \ (ARRAY)[i].arg2, (ARRAY)[i].arg3, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions); \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_c_f(TEST_NAME, FUNC_NAME, ARG1, ARG2, EXPECTED, \ - MAX_ULP, EXCEPTIONS) \ - check_float (TEST_NAME, \ - FUNC (FUNC_NAME) (BUILD_COMPLEX (ARG1, ARG2)), \ - EXPECTED, MAX_ULP, EXCEPTIONS) +#define RUN_TEST_c_f(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \ + EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_float (test_name, \ + FUNC (FUNC_NAME) (BUILD_COMPLEX (ARG1, ARG2)), \ + EXPECTED, EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_c_f(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_c_f ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].argr, \ + RUN_TEST_c_f ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].argr, \ (ARRAY)[i].argc, (ARRAY)[i].expected, \ - (ARRAY)[i].max_ulp, (ARRAY)[i].exceptions); \ + (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_f_f1(TEST_NAME, FUNC_NAME, ARG, EXPECTED, \ - MAX_ULP, EXCEPTIONS, \ - EXTRA_NAME, EXTRA_VAR, EXTRA_TEST, \ - EXTRA_EXPECTED, EXTRA_ULP) \ +#define RUN_TEST_f_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \ + EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \ + EXTRA_EXPECTED) \ do \ { \ + COMMON_TEST_SETUP (ARG_STR); \ (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \ - check_float (TEST_NAME, FUNC (FUNC_NAME) (ARG), EXPECTED, \ - MAX_ULP, EXCEPTIONS); \ + check_float (test_name, FUNC (FUNC_NAME) (ARG), EXPECTED, \ + EXCEPTIONS); \ + EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \ if (EXTRA_TEST) \ - check_int (EXTRA_NAME, EXTRA_VAR, EXTRA_EXPECTED, \ - EXTRA_ULP, 0); \ + check_int (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \ + EXTRA_OUTPUT_TEST_CLEANUP (1); \ + COMMON_TEST_CLEANUP; \ } \ while (0) #define RUN_TEST_LOOP_f_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_f_f1 ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions, (ARRAY)[i].extra_name, \ + RUN_TEST_f_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions, \ EXTRA_VAR, (ARRAY)[i].extra_test, \ - (ARRAY)[i].extra_expected, (ARRAY)[i].extra_ulp); \ + (ARRAY)[i].extra_expected); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_fF_f1(TEST_NAME, FUNC_NAME, ARG, EXPECTED, \ - MAX_ULP, EXCEPTIONS, \ - EXTRA_NAME, EXTRA_VAR, EXTRA_TEST, \ - EXTRA_EXPECTED, EXTRA_ULP) \ +#define RUN_TEST_fF_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \ + EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \ + EXTRA_EXPECTED) \ do \ { \ + COMMON_TEST_SETUP (ARG_STR); \ (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \ - check_float (TEST_NAME, FUNC (FUNC_NAME) (ARG, &(EXTRA_VAR)), \ - EXPECTED, MAX_ULP, EXCEPTIONS); \ + check_float (test_name, FUNC (FUNC_NAME) (ARG, &(EXTRA_VAR)), \ + EXPECTED, EXCEPTIONS); \ + EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \ if (EXTRA_TEST) \ - check_float (EXTRA_NAME, EXTRA_VAR, EXTRA_EXPECTED, \ - EXTRA_ULP, 0); \ + check_float (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \ + EXTRA_OUTPUT_TEST_CLEANUP (1); \ + COMMON_TEST_CLEANUP; \ } \ while (0) #define RUN_TEST_LOOP_fF_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_fF_f1 ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions, (ARRAY)[i].extra_name, \ + RUN_TEST_fF_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions, \ EXTRA_VAR, (ARRAY)[i].extra_test, \ - (ARRAY)[i].extra_expected, (ARRAY)[i].extra_ulp); \ + (ARRAY)[i].extra_expected); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_fI_f1(TEST_NAME, FUNC_NAME, ARG, EXPECTED, \ - MAX_ULP, EXCEPTIONS, \ - EXTRA_NAME, EXTRA_VAR, EXTRA_TEST, \ - EXTRA_EXPECTED, EXTRA_ULP) \ +#define RUN_TEST_fI_f1(ARG_STR, FUNC_NAME, ARG, EXPECTED, \ + EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \ + EXTRA_EXPECTED) \ do \ { \ + COMMON_TEST_SETUP (ARG_STR); \ (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \ - check_float (TEST_NAME, FUNC (FUNC_NAME) (ARG, &(EXTRA_VAR)), \ - EXPECTED, MAX_ULP, EXCEPTIONS); \ + check_float (test_name, FUNC (FUNC_NAME) (ARG, &(EXTRA_VAR)), \ + EXPECTED, EXCEPTIONS); \ + EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \ if (EXTRA_TEST) \ - check_int (EXTRA_NAME, EXTRA_VAR, EXTRA_EXPECTED, \ - EXTRA_ULP, 0); \ + check_int (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \ + EXTRA_OUTPUT_TEST_CLEANUP (1); \ + COMMON_TEST_CLEANUP; \ } \ while (0) #define RUN_TEST_LOOP_fI_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, EXTRA_VAR) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_fI_f1 ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions, (ARRAY)[i].extra_name, \ + RUN_TEST_fI_f1 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions, \ EXTRA_VAR, (ARRAY)[i].extra_test, \ - (ARRAY)[i].extra_expected, (ARRAY)[i].extra_ulp); \ + (ARRAY)[i].extra_expected); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_ffI_f1(TEST_NAME, FUNC_NAME, ARG1, ARG2, EXPECTED, \ - MAX_ULP, EXCEPTIONS, \ - EXTRA_NAME, EXTRA_VAR, EXTRA_TEST, \ - EXTRA_EXPECTED, EXTRA_ULP) \ +#define RUN_TEST_ffI_f1(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \ + EXCEPTIONS, EXTRA_VAR, EXTRA_TEST, \ + EXTRA_EXPECTED) \ do \ { \ + COMMON_TEST_SETUP (ARG_STR); \ (EXTRA_VAR) = (EXTRA_EXPECTED) == 0 ? 1 : 0; \ - check_float (TEST_NAME, \ + check_float (test_name, \ FUNC (FUNC_NAME) (ARG1, ARG2, &(EXTRA_VAR)), \ - EXPECTED, MAX_ULP, EXCEPTIONS); \ + EXPECTED, EXCEPTIONS); \ + EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \ if (EXTRA_TEST) \ - check_int (EXTRA_NAME, EXTRA_VAR, EXTRA_EXPECTED, \ - EXTRA_ULP, 0); \ + check_int (extra1_name, EXTRA_VAR, EXTRA_EXPECTED, 0); \ + EXTRA_OUTPUT_TEST_CLEANUP (1); \ + COMMON_TEST_CLEANUP; \ } \ while (0) #define RUN_TEST_LOOP_ffI_f1(FUNC_NAME, ARRAY, ROUNDING_MODE, \ EXTRA_VAR) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_ffI_f1 ((ARRAY)[i].test_name, FUNC_NAME, \ + RUN_TEST_ffI_f1 ((ARRAY)[i].arg_str, FUNC_NAME, \ (ARRAY)[i].arg1, (ARRAY)[i].arg2, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions, (ARRAY)[i].extra_name, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions, \ EXTRA_VAR, (ARRAY)[i].extra_test, \ - (ARRAY)[i].extra_expected, \ - (ARRAY)[i].extra_ulp); \ + (ARRAY)[i].extra_expected); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_c_c(TEST_NAME, FUNC_NAME, ARGR, ARGC, EXPR, EXPC, \ - MAX_ULP, EXCEPTIONS) \ - check_complex (TEST_NAME, \ - FUNC (FUNC_NAME) (BUILD_COMPLEX (ARGR, ARGC)), \ - BUILD_COMPLEX (EXPR, EXPC), \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_c_c(ARG_STR, FUNC_NAME, ARGR, ARGC, EXPR, EXPC, \ + EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_complex (test_name, \ + FUNC (FUNC_NAME) (BUILD_COMPLEX (ARGR, ARGC)), \ + BUILD_COMPLEX (EXPR, EXPC), EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_c_c(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_c_c ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].argr, \ + RUN_TEST_c_c ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].argr, \ (ARRAY)[i].argc, (ARRAY)[i].expr, (ARRAY)[i].expc, \ - (ARRAY)[i].max_ulp, (ARRAY)[i].exceptions); \ + (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_cc_c(TEST_NAME, FUNC_NAME, ARG1R, ARG1C, ARG2R, ARG2C, \ - EXPR, EXPC, MAX_ULP, EXCEPTIONS) \ - check_complex (TEST_NAME, \ - FUNC (FUNC_NAME) (BUILD_COMPLEX (ARG1R, ARG1C), \ - BUILD_COMPLEX (ARG2R, ARG2C)), \ - BUILD_COMPLEX (EXPR, EXPC), \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_cc_c(ARG_STR, FUNC_NAME, ARG1R, ARG1C, ARG2R, ARG2C, \ + EXPR, EXPC, EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_complex (test_name, \ + FUNC (FUNC_NAME) (BUILD_COMPLEX (ARG1R, ARG1C), \ + BUILD_COMPLEX (ARG2R, ARG2C)), \ + BUILD_COMPLEX (EXPR, EXPC), EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_cc_c(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_cc_c ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg1r, \ + RUN_TEST_cc_c ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg1r, \ (ARRAY)[i].arg1c, (ARRAY)[i].arg2r, \ (ARRAY)[i].arg2c, (ARRAY)[i].expr, \ - (ARRAY)[i].expc, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions); \ + (ARRAY)[i].expc, (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_f_i(TEST_NAME, FUNC_NAME, ARG, EXPECTED, \ - MAX_ULP, EXCEPTIONS) \ - check_int (TEST_NAME, FUNC (FUNC_NAME) (ARG), EXPECTED, \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_f_i(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_int (test_name, FUNC (FUNC_NAME) (ARG), EXPECTED, \ + EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_f_i(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_f_i ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions); \ + RUN_TEST_f_i ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_f_i_tg(TEST_NAME, FUNC_NAME, ARG, EXPECTED, \ - MAX_ULP, EXCEPTIONS) \ - check_int (TEST_NAME, FUNC_NAME (ARG), EXPECTED, \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_f_i_tg(ARG_STR, FUNC_NAME, ARG, EXPECTED, \ + EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_int (test_name, FUNC_NAME (ARG), EXPECTED, EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_f_i_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_f_i_tg ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions); \ + RUN_TEST_f_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_ff_i_tg(TEST_NAME, FUNC_NAME, ARG1, ARG2, EXPECTED, \ - MAX_ULP, EXCEPTIONS) \ - check_int (TEST_NAME, FUNC_NAME (ARG1, ARG2), EXPECTED, \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_ff_i_tg(ARG_STR, FUNC_NAME, ARG1, ARG2, EXPECTED, \ + EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_int (test_name, FUNC_NAME (ARG1, ARG2), EXPECTED, \ + EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_ff_i_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_ff_i_tg ((ARRAY)[i].test_name, FUNC_NAME, \ + RUN_TEST_ff_i_tg ((ARRAY)[i].arg_str, FUNC_NAME, \ (ARRAY)[i].arg1, (ARRAY)[i].arg2, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions); \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_f_b(TEST_NAME, FUNC_NAME, ARG, EXPECTED, \ - MAX_ULP, EXCEPTIONS) \ - check_bool (TEST_NAME, FUNC (FUNC_NAME) (ARG), EXPECTED, \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_f_b(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_bool (test_name, FUNC (FUNC_NAME) (ARG), EXPECTED, \ + EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_f_b(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_f_b ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions); \ + RUN_TEST_f_b ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_f_b_tg(TEST_NAME, FUNC_NAME, ARG, EXPECTED, \ - MAX_ULP, EXCEPTIONS) \ - check_bool (TEST_NAME, FUNC_NAME (ARG), EXPECTED, \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_f_b_tg(ARG_STR, FUNC_NAME, ARG, EXPECTED, \ + EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_bool (test_name, FUNC_NAME (ARG), EXPECTED, EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_f_b_tg(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_f_b_tg ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions); \ + RUN_TEST_f_b_tg ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_f_l(TEST_NAME, FUNC_NAME, ARG, EXPECTED, \ - MAX_ULP, EXCEPTIONS) \ - check_long (TEST_NAME, FUNC (FUNC_NAME) (ARG), EXPECTED, \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_f_l(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_long (test_name, FUNC (FUNC_NAME) (ARG), EXPECTED, \ + EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_f_l(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_f_l ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions); \ + RUN_TEST_f_l ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_f_L(TEST_NAME, FUNC_NAME, ARG, EXPECTED, \ - MAX_ULP, EXCEPTIONS) \ - check_longlong (TEST_NAME, FUNC (FUNC_NAME) (ARG), EXPECTED, \ - MAX_ULP, EXCEPTIONS) +#define RUN_TEST_f_L(ARG_STR, FUNC_NAME, ARG, EXPECTED, EXCEPTIONS) \ + do \ + { \ + COMMON_TEST_SETUP (ARG_STR); \ + check_longlong (test_name, FUNC (FUNC_NAME) (ARG), EXPECTED, \ + EXCEPTIONS); \ + COMMON_TEST_CLEANUP; \ + } \ + while (0) #define RUN_TEST_LOOP_f_L(FUNC_NAME, ARRAY, ROUNDING_MODE) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_f_L ((ARRAY)[i].test_name, FUNC_NAME, (ARRAY)[i].arg, \ - (ARRAY)[i].expected, (ARRAY)[i].max_ulp, \ - (ARRAY)[i].exceptions); \ + RUN_TEST_f_L ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].expected, (ARRAY)[i].exceptions); \ ROUND_RESTORE_ ## ROUNDING_MODE -#define RUN_TEST_sincos(ARG, TEST_NAME_SIN, SIN_RES_VAR, EXPECTED_SIN, \ - MAX_ULP_SIN, TEST_NAME_COS, COS_RES_VAR, \ - EXPECTED_COS, MAX_ULP_COS, EXCEPTIONS) \ +#define RUN_TEST_fFF_11(ARG_STR, FUNC_NAME, ARG, EXCEPTIONS, \ + EXTRA1_VAR, EXTRA1_TEST, \ + EXTRA1_EXPECTED, EXTRA2_VAR, \ + EXTRA2_TEST, EXTRA2_EXPECTED) \ do \ { \ - FUNC (sincos) (ARG, &(SIN_RES_VAR), &(COS_RES_VAR)); \ - check_float (TEST_NAME_SIN, SIN_RES_VAR, \ - EXPECTED_SIN, MAX_ULP_SIN, EXCEPTIONS); \ - check_float (TEST_NAME_COS, COS_RES_VAR, \ - EXPECTED_COS, MAX_ULP_COS, 0); \ + COMMON_TEST_SETUP (ARG_STR); \ + FUNC (FUNC_NAME) (ARG, &(EXTRA1_VAR), &(EXTRA2_VAR)); \ + EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 1); \ + if (EXTRA1_TEST) \ + check_float (extra1_name, EXTRA1_VAR, EXTRA1_EXPECTED, \ + EXCEPTIONS); \ + EXTRA_OUTPUT_TEST_CLEANUP (1); \ + EXTRA_OUTPUT_TEST_SETUP (ARG_STR, 2); \ + if (EXTRA2_TEST) \ + check_float (extra2_name, EXTRA2_VAR, EXTRA2_EXPECTED, 0); \ + EXTRA_OUTPUT_TEST_CLEANUP (2); \ + COMMON_TEST_CLEANUP; \ } \ while (0) -#define RUN_TEST_LOOP_sincos(ARRAY, ROUNDING_MODE, SIN_RES_VAR, \ - COS_RES_VAR) \ +#define RUN_TEST_LOOP_fFF_11(FUNC_NAME, ARRAY, ROUNDING_MODE, \ + EXTRA1_VAR, EXTRA2_VAR) \ IF_ROUND_INIT_ ## ROUNDING_MODE \ for (size_t i = 0; i < sizeof (ARRAY) / sizeof (ARRAY)[0]; i++) \ - RUN_TEST_sincos ((ARRAY)[i].arg, (ARRAY)[i].test_name_sin, \ - SIN_RES_VAR, (ARRAY)[i].expected_sin, \ - (ARRAY)[i].max_ulp_sin, \ - (ARRAY)[i].test_name_cos, COS_RES_VAR, \ - (ARRAY)[i].expected_cos, (ARRAY)[i].max_ulp_cos, \ - (ARRAY)[i].exceptions); \ + RUN_TEST_fFF_11 ((ARRAY)[i].arg_str, FUNC_NAME, (ARRAY)[i].arg, \ + (ARRAY)[i].exceptions, \ + EXTRA1_VAR, (ARRAY)[i].extra1_test, \ + (ARRAY)[i].extra1_expected, \ + EXTRA2_VAR, \ + (ARRAY)[i].extra2_test, \ + (ARRAY)[i].extra2_expected); \ ROUND_RESTORE_ ## ROUNDING_MODE - +/* Start and end the tests for a given function. */ +#define START(FUNC) \ + const char *this_func = #FUNC; \ + init_max_error () +#define END \ + print_max_error (this_func) +#define END_COMPLEX \ + print_complex_max_error (this_func) /* This is to prevent messages from the SVID libm emulation. */ int @@ -1342,7 +1505,6 @@ matherr (struct exception *x __attribute__ ((unused))) static const struct test_f_f_data acos_test_data[] = { - START_DATA (acos), TEST_f_f (acos, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM), TEST_f_f (acos, minus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM), TEST_f_f (acos, qnan_value, qnan_value), @@ -1374,7 +1536,6 @@ static const struct test_f_f_data acos_test_data[] = TEST_f_f (acos, 0x0.ffffffffffffffffp0L, 3.2927225399135962333718255320079907245059e-10L), TEST_f_f (acos, -0x0.ffffffffffffffffp0L, 3.1415926532605209844712837599423203309964L), #endif - END_DATA (acos) }; static void @@ -1382,20 +1543,18 @@ acos_test (void) { START (acos); RUN_TEST_LOOP_f_f (acos, acos_test_data, ); - END (acos); + END; } static const struct test_f_f_data acos_tonearest_test_data[] = { - START_DATA (acos_tonearest), TEST_f_f (acos, 0, M_PI_2l), TEST_f_f (acos, minus_zero, M_PI_2l), TEST_f_f (acos, 1, 0), TEST_f_f (acos, -1, M_PIl), TEST_f_f (acos, 0.5, M_PI_6l*2.0), TEST_f_f (acos, -0.5, M_PI_6l*4.0), - END_DATA (acos_tonearest) }; static void @@ -1403,20 +1562,18 @@ acos_test_tonearest (void) { START (acos_tonearest); RUN_TEST_LOOP_f_f (acos, acos_tonearest_test_data, FE_TONEAREST); - END (acos_tonearest); + END; } static const struct test_f_f_data acos_towardzero_test_data[] = { - START_DATA (acos_towardzero), TEST_f_f (acos, 0, M_PI_2l), TEST_f_f (acos, minus_zero, M_PI_2l), TEST_f_f (acos, 1, 0), TEST_f_f (acos, -1, M_PIl), TEST_f_f (acos, 0.5, M_PI_6l*2.0), TEST_f_f (acos, -0.5, M_PI_6l*4.0), - END_DATA (acos_towardzero) }; static void @@ -1424,20 +1581,18 @@ acos_test_towardzero (void) { START (acos_towardzero); RUN_TEST_LOOP_f_f (acos, acos_towardzero_test_data, FE_TOWARDZERO); - END (acos_towardzero); + END; } static const struct test_f_f_data acos_downward_test_data[] = { - START_DATA (acos_downward), TEST_f_f (acos, 0, M_PI_2l), TEST_f_f (acos, minus_zero, M_PI_2l), TEST_f_f (acos, 1, 0), TEST_f_f (acos, -1, M_PIl), TEST_f_f (acos, 0.5, M_PI_6l*2.0), TEST_f_f (acos, -0.5, M_PI_6l*4.0), - END_DATA (acos_downward) }; static void @@ -1445,20 +1600,18 @@ acos_test_downward (void) { START (acos_downward); RUN_TEST_LOOP_f_f (acos, acos_downward_test_data, FE_DOWNWARD); - END (acos_downward); + END; } static const struct test_f_f_data acos_upward_test_data[] = { - START_DATA (acos_upward), TEST_f_f (acos, 0, M_PI_2l), TEST_f_f (acos, minus_zero, M_PI_2l), TEST_f_f (acos, 1, 0), TEST_f_f (acos, -1, M_PIl), TEST_f_f (acos, 0.5, M_PI_6l*2.0), TEST_f_f (acos, -0.5, M_PI_6l*4.0), - END_DATA (acos_upward) }; static void @@ -1466,12 +1619,11 @@ acos_test_upward (void) { START (acos_upward); RUN_TEST_LOOP_f_f (acos, acos_upward_test_data, FE_UPWARD); - END (acos_upward); + END; } static const struct test_f_f_data acosh_test_data[] = { - START_DATA (acosh), TEST_f_f (acosh, plus_infty, plus_infty), TEST_f_f (acosh, minus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM), TEST_f_f (acosh, qnan_value, qnan_value), @@ -1482,7 +1634,6 @@ static const struct test_f_f_data acosh_test_data[] = TEST_f_f (acosh, 1, 0), TEST_f_f (acosh, 7, 2.63391579384963341725009269461593689L), - END_DATA (acosh) }; static void @@ -1490,12 +1641,11 @@ acosh_test (void) { START (acosh); RUN_TEST_LOOP_f_f (acosh, acosh_test_data, ); - END (acosh); + END; } static const struct test_f_f_data asin_test_data[] = { - START_DATA (asin), TEST_f_f (asin, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM), TEST_f_f (asin, minus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM), TEST_f_f (asin, qnan_value, qnan_value), @@ -1525,7 +1675,6 @@ static const struct test_f_f_data asin_test_data[] = TEST_f_f (asin, 0x0.ffffffffffffffffp0L, 1.5707963264656243652399620683025688888978L), TEST_f_f (asin, -0x0.ffffffffffffffffp0L, -1.5707963264656243652399620683025688888978L), #endif - END_DATA (asin) }; static void @@ -1533,20 +1682,18 @@ asin_test (void) { START (asin); RUN_TEST_LOOP_f_f (asin, asin_test_data, ); - END (asin); + END; } static const struct test_f_f_data asin_tonearest_test_data[] = { - START_DATA (asin_tonearest), TEST_f_f (asin, 0, 0), TEST_f_f (asin, minus_zero, minus_zero), TEST_f_f (asin, 0.5, M_PI_6l), TEST_f_f (asin, -0.5, -M_PI_6l), TEST_f_f (asin, 1.0, M_PI_2l), TEST_f_f (asin, -1.0, -M_PI_2l), - END_DATA (asin_tonearest) }; static void @@ -1554,20 +1701,18 @@ asin_test_tonearest (void) { START (asin_tonearest); RUN_TEST_LOOP_f_f (asin, asin_tonearest_test_data, FE_TONEAREST); - END (asin_tonearest); + END; } static const struct test_f_f_data asin_towardzero_test_data[] = { - START_DATA (asin_towardzero), TEST_f_f (asin, 0, 0), TEST_f_f (asin, minus_zero, minus_zero), TEST_f_f (asin, 0.5, M_PI_6l), TEST_f_f (asin, -0.5, -M_PI_6l), TEST_f_f (asin, 1.0, M_PI_2l), TEST_f_f (asin, -1.0, -M_PI_2l), - END_DATA (asin_towardzero) }; static void @@ -1575,20 +1720,18 @@ asin_test_towardzero (void) { START (asin_towardzero); RUN_TEST_LOOP_f_f (asin, asin_towardzero_test_data, FE_TOWARDZERO); - END (asin_towardzero); + END; } static const struct test_f_f_data asin_downward_test_data[] = { - START_DATA (asin_downward), TEST_f_f (asin, 0, 0), TEST_f_f (asin, minus_zero, minus_zero), TEST_f_f (asin, 0.5, M_PI_6l), TEST_f_f (asin, -0.5, -M_PI_6l), TEST_f_f (asin, 1.0, M_PI_2l), TEST_f_f (asin, -1.0, -M_PI_2l), - END_DATA (asin_downward) }; static void @@ -1596,20 +1739,18 @@ asin_test_downward (void) { START (asin_downward); RUN_TEST_LOOP_f_f (asin, asin_downward_test_data, FE_DOWNWARD); - END (asin_downward); + END; } static const struct test_f_f_data asin_upward_test_data[] = { - START_DATA (asin_upward), TEST_f_f (asin, 0, 0), TEST_f_f (asin, minus_zero, minus_zero), TEST_f_f (asin, 0.5, M_PI_6l), TEST_f_f (asin, -0.5, -M_PI_6l), TEST_f_f (asin, 1.0, M_PI_2l), TEST_f_f (asin, -1.0, -M_PI_2l), - END_DATA (asin_upward) }; static void @@ -1617,12 +1758,11 @@ asin_test_upward (void) { START (asin_upward); RUN_TEST_LOOP_f_f (asin, asin_upward_test_data, FE_UPWARD); - END (asin_upward); + END; } static const struct test_f_f_data asinh_test_data[] = { - START_DATA (asinh), TEST_f_f (asinh, 0, 0), TEST_f_f (asinh, minus_zero, minus_zero), #ifndef TEST_INLINE @@ -1631,7 +1771,6 @@ static const struct test_f_f_data asinh_test_data[] = #endif TEST_f_f (asinh, qnan_value, qnan_value), TEST_f_f (asinh, 0.75L, 0.693147180559945309417232121458176568L), - END_DATA (asinh) }; static void @@ -1639,12 +1778,11 @@ asinh_test (void) { START (asinh); RUN_TEST_LOOP_f_f (asinh, asinh_test_data, ); - END (asinh); + END; } static const struct test_f_f_data atan_test_data[] = { - START_DATA (atan), TEST_f_f (atan, 0, 0), TEST_f_f (atan, minus_zero, minus_zero), @@ -1666,7 +1804,6 @@ static const struct test_f_f_data atan_test_data[] = #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 TEST_f_f (atan, 0x1p-10000L, 0x1p-10000L), #endif - END_DATA (atan) }; static void @@ -1674,14 +1811,13 @@ atan_test (void) { START (atan); RUN_TEST_LOOP_f_f (atan, atan_test_data, ); - END (atan); + END; } static const struct test_f_f_data atanh_test_data[] = { - START_DATA (atanh), TEST_f_f (atanh, 0, 0), TEST_f_f (atanh, minus_zero, minus_zero), @@ -1696,7 +1832,6 @@ static const struct test_f_f_data atanh_test_data[] = TEST_f_f (atanh, -max_value, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM), TEST_f_f (atanh, 0.75L, 0.972955074527656652552676371721589865L), - END_DATA (atanh) }; static void @@ -1704,12 +1839,11 @@ atanh_test (void) { START (atanh); RUN_TEST_LOOP_f_f (atanh, atanh_test_data, ); - END (atanh); + END; } static const struct test_ff_f_data atan2_test_data[] = { - START_DATA (atan2), /* atan2 (0,x) == 0 for x > 0. */ TEST_ff_f (atan2, 0, 1, 0), @@ -1780,7 +1914,6 @@ static const struct test_ff_f_data atan2_test_data[] = #if defined TEST_LDOUBLE && LDBL_MANT_DIG >= 64 TEST_ff_f (atan2, 0x1.00000000000001p0L, 0x1.00000000000001p0L, M_PI_4l), #endif - END_DATA (atan2) }; static void @@ -1788,12 +1921,11 @@ atan2_test (void) { START (atan2); RUN_TEST_LOOP_ff_f (atan2, atan2_test_data, ); - END (atan2); + END; } static const struct test_c_f_data cabs_test_data[] = { - START_DATA (cabs); /* cabs (x + iy) is specified as hypot (x,y) */ /* cabs (+inf + i x) == +inf. */ @@ -1825,7 +1957,6 @@ static const struct test_c_f_data cabs_test_data[] = TEST_c_f (cabs, 5.7e7L, 0, 5.7e7L), TEST_c_f (cabs, 0.75L, 1.25L, 1.45773797371132511771853821938639577L), - END_DATA (cabs); }; static void @@ -1833,13 +1964,12 @@ cabs_test (void) { START (cabs); RUN_TEST_LOOP_c_f (cabs, cabs_test_data, ); - END (cabs); + END; } static const struct test_c_c_data cacos_test_data[] = { - START_DATA (cacos), TEST_c_c (cacos, 0, 0, M_PI_2l, minus_zero), TEST_c_c (cacos, minus_zero, 0, M_PI_2l, minus_zero), TEST_c_c (cacos, minus_zero, minus_zero, M_PI_2l, 0.0), @@ -2518,7 +2648,6 @@ static const struct test_c_c_data cacos_test_data[] = TEST_c_c (cacos, 0.75L, 1.25L, 1.11752014915610270578240049553777969L, -1.13239363160530819522266333696834467L), TEST_c_c (cacos, -2, -3, 2.1414491111159960199416055713254211L, 1.9833870299165354323470769028940395L), - END_DATA (cacos) }; static void @@ -2526,12 +2655,11 @@ cacos_test (void) { START (cacos); RUN_TEST_LOOP_c_c (cacos, cacos_test_data, ); - END (cacos, complex); + END_COMPLEX; } static const struct test_c_c_data cacosh_test_data[] = { - START_DATA (cacosh), TEST_c_c (cacosh, 0, 0, 0.0, M_PI_2l), TEST_c_c (cacosh, minus_zero, 0, 0.0, M_PI_2l), TEST_c_c (cacosh, 0, minus_zero, 0.0, -M_PI_2l), @@ -3204,7 +3332,6 @@ static const struct test_c_c_data cacosh_test_data[] = TEST_c_c (cacosh, 0.75L, 1.25L, 1.13239363160530819522266333696834467L, 1.11752014915610270578240049553777969L), TEST_c_c (cacosh, -2, -3, 1.9833870299165354323470769028940395L, -2.1414491111159960199416055713254211L), - END_DATA (cacosh) }; static void @@ -3212,13 +3339,12 @@ cacosh_test (void) { START (cacosh); RUN_TEST_LOOP_c_c (cacosh, cacosh_test_data, ); - END (cacosh, complex); + END_COMPLEX; } static const struct test_c_f_data carg_test_data[] = { - START_DATA (carg); /* carg (x + iy) is specified as atan2 (y, x) */ /* carg (x + i 0) == 0 for x > 0. */ @@ -3277,7 +3403,6 @@ static const struct test_c_f_data carg_test_data[] = TEST_c_f (carg, minus_infty, minus_infty, -M_PI_34l), TEST_c_f (carg, qnan_value, qnan_value, qnan_value), - END_DATA (carg); }; static void @@ -3285,12 +3410,11 @@ carg_test (void) { START (carg); RUN_TEST_LOOP_c_f (carg, carg_test_data, ); - END (carg); + END; } static const struct test_c_c_data casin_test_data[] = { - START_DATA (casin), TEST_c_c (casin, 0, 0, 0.0, 0.0), TEST_c_c (casin, minus_zero, 0, minus_zero, 0.0), TEST_c_c (casin, 0, minus_zero, 0.0, minus_zero), @@ -3973,7 +4097,6 @@ static const struct test_c_c_data casin_test_data[] = TEST_c_c (casin, 0.75L, 1.25L, 0.453276177638793913448921196101971749L, 1.13239363160530819522266333696834467L), TEST_c_c (casin, -2, -3, -0.57065278432109940071028387968566963L, -1.9833870299165354323470769028940395L), - END_DATA (casin) }; static void @@ -3981,13 +4104,12 @@ casin_test (void) { START (casin); RUN_TEST_LOOP_c_c (casin, casin_test_data, ); - END (casin, complex); + END_COMPLEX; } static const struct test_c_c_data casinh_test_data[] = { - START_DATA (casinh), TEST_c_c (casinh, 0, 0, 0.0, 0.0), TEST_c_c (casinh, minus_zero, 0, minus_zero, 0), TEST_c_c (casinh, 0, minus_zero, 0.0, minus_zero), @@ -4670,7 +4792,6 @@ static const struct test_c_c_data casinh_test_data[] = TEST_c_c (casinh, 0.75L, 1.25L, 1.03171853444778027336364058631006594L, 0.911738290968487636358489564316731207L), TEST_c_c (casinh, -2, -3, -1.9686379257930962917886650952454982L, -0.96465850440760279204541105949953237L), - END_DATA (casinh) }; static void @@ -4678,13 +4799,12 @@ casinh_test (void) { START (casinh); RUN_TEST_LOOP_c_c (casinh, casinh_test_data, ); - END (casinh, complex); + END_COMPLEX; } static const struct test_c_c_data catan_test_data[] = { - START_DATA (catan), TEST_c_c (catan, 0, 0, 0, 0), TEST_c_c (catan, minus_zero, 0, minus_zero, 0), TEST_c_c (catan, 0, minus_zero, 0, minus_zero), @@ -5181,7 +5301,6 @@ static const struct test_c_c_data catan_test_data[] = TEST_c_c (catan, 0.75L, 1.25L, 1.10714871779409050301706546017853704L, 0.549306144334054845697622618461262852L), TEST_c_c (catan, -2, -3, -1.4099210495965755225306193844604208L, -0.22907268296853876629588180294200276L), - END_DATA (catan) }; static void @@ -5189,12 +5308,11 @@ catan_test (void) { START (catan); RUN_TEST_LOOP_c_c (catan, catan_test_data, ); - END (catan, complex); + END_COMPLEX; } static const struct test_c_c_data catanh_test_data[] = { - START_DATA (catanh), TEST_c_c (catanh, 0, 0, 0.0, 0.0), TEST_c_c (catanh, minus_zero, 0, minus_zero, 0.0), TEST_c_c (catanh, 0, minus_zero, 0.0, minus_zero), @@ -5690,7 +5808,6 @@ static const struct test_c_c_data catanh_test_data[] = TEST_c_c (catanh, 0.75L, 1.25L, 0.261492138795671927078652057366532140L, 0.996825126463918666098902241310446708L), TEST_c_c (catanh, -2, -3, -0.14694666622552975204743278515471595L, -1.3389725222944935611241935759091443L), - END_DATA (catanh) }; static void @@ -5698,12 +5815,11 @@ catanh_test (void) { START (catanh); RUN_TEST_LOOP_c_c (catanh, catanh_test_data, ); - END (catanh, complex); + END_COMPLEX; } static const struct test_f_f_data cbrt_test_data[] = { - START_DATA (cbrt), TEST_f_f (cbrt, 0.0, 0.0), TEST_f_f (cbrt, minus_zero, minus_zero), @@ -5716,7 +5832,6 @@ static const struct test_f_f_data cbrt_test_data[] = TEST_f_f (cbrt, -27.0, -3.0), TEST_f_f (cbrt, 0.9921875L, 0.997389022060725270579075195353955217L), TEST_f_f (cbrt, 0.75L, 0.908560296416069829445605878163630251L), - END_DATA (cbrt) }; static void @@ -5724,13 +5839,12 @@ cbrt_test (void) { START (cbrt); RUN_TEST_LOOP_f_f (cbrt, cbrt_test_data, ); - END (cbrt); + END; } static const struct test_c_c_data ccos_test_data[] = { - START_DATA (ccos), TEST_c_c (ccos, 0.0, 0.0, 1.0, minus_zero), TEST_c_c (ccos, minus_zero, 0.0, 1.0, 0.0), TEST_c_c (ccos, 0.0, minus_zero, 1.0, 0.0), @@ -5817,7 +5931,6 @@ static const struct test_c_c_data ccos_test_data[] = TEST_c_c (ccos, min_subnorm_value * 0x1p120, 0x1p-120, 1.0, -min_subnorm_value, UNDERFLOW_EXCEPTION), TEST_c_c (ccos, 0x1p-120, min_subnorm_value * 0x1p120, 1.0, -min_subnorm_value, UNDERFLOW_EXCEPTION), - END_DATA (ccos) }; static void @@ -5825,13 +5938,12 @@ ccos_test (void) { START (ccos); RUN_TEST_LOOP_c_c (ccos, ccos_test_data, ); - END (ccos, complex); + END_COMPLEX; } static const struct test_c_c_data ccosh_test_data[] = { - START_DATA (ccosh), TEST_c_c (ccosh, 0.0, 0.0, 1.0, 0.0), TEST_c_c (ccosh, minus_zero, 0.0, 1.0, minus_zero), TEST_c_c (ccosh, 0.0, minus_zero, 1.0, minus_zero), @@ -5919,7 +6031,6 @@ static const struct test_c_c_data ccosh_test_data[] = TEST_c_c (ccosh, min_subnorm_value * 0x1p120, 0x1p-120, 1.0, min_subnorm_value, UNDERFLOW_EXCEPTION), TEST_c_c (ccosh, 0x1p-120, min_subnorm_value * 0x1p120, 1.0, min_subnorm_value, UNDERFLOW_EXCEPTION), - END_DATA (ccosh) }; static void @@ -5927,13 +6038,12 @@ ccosh_test (void) { START (ccosh); RUN_TEST_LOOP_c_c (ccosh, ccosh_test_data, ); - END (ccosh, complex); + END_COMPLEX; } static const struct test_f_f_data ceil_test_data[] = { - START_DATA (ceil), TEST_f_f (ceil, 0.0, 0.0, NO_INEXACT_EXCEPTION), TEST_f_f (ceil, minus_zero, minus_zero, NO_INEXACT_EXCEPTION), TEST_f_f (ceil, plus_infty, plus_infty, NO_INEXACT_EXCEPTION), @@ -6019,7 +6129,6 @@ static const struct test_f_f_data ceil_test_data[] = TEST_f_f (ceil, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L), TEST_f_f (ceil, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L), #endif - END_DATA (ceil) }; static void @@ -6027,13 +6136,12 @@ ceil_test (void) { START (ceil); RUN_TEST_LOOP_f_f (ceil, ceil_test_data, ); - END (ceil); + END; } static const struct test_c_c_data cexp_test_data[] = { - START_DATA (cexp), TEST_c_c (cexp, plus_zero, plus_zero, 1, 0.0), TEST_c_c (cexp, minus_zero, plus_zero, 1, 0.0), TEST_c_c (cexp, plus_zero, minus_zero, 1, minus_zero), @@ -6129,7 +6237,6 @@ static const struct test_c_c_data cexp_test_data[] = TEST_c_c (cexp, min_value, min_subnorm_value, 1.0, min_subnorm_value, UNDERFLOW_EXCEPTION), TEST_c_c (cexp, min_value, -min_subnorm_value, 1.0, -min_subnorm_value, UNDERFLOW_EXCEPTION), - END_DATA (cexp) }; static void @@ -6137,13 +6244,12 @@ cexp_test (void) { START (cexp); RUN_TEST_LOOP_c_c (cexp, cexp_test_data, ); - END (cexp, complex); + END_COMPLEX; } static const struct test_c_f_data cimag_test_data[] = { - START_DATA (cimag); TEST_c_f (cimag, 1.0, 0.0, 0.0, NO_INEXACT_EXCEPTION), TEST_c_f (cimag, 1.0, minus_zero, minus_zero, NO_INEXACT_EXCEPTION), TEST_c_f (cimag, 1.0, qnan_value, qnan_value, NO_INEXACT_EXCEPTION), @@ -6151,7 +6257,6 @@ static const struct test_c_f_data cimag_test_data[] = TEST_c_f (cimag, 1.0, plus_infty, plus_infty, NO_INEXACT_EXCEPTION), TEST_c_f (cimag, 1.0, minus_infty, minus_infty, NO_INEXACT_EXCEPTION), TEST_c_f (cimag, 2.0, 3.0, 3.0, NO_INEXACT_EXCEPTION), - END_DATA (cimag); }; static void @@ -6159,12 +6264,11 @@ cimag_test (void) { START (cimag); RUN_TEST_LOOP_c_f (cimag, cimag_test_data, ); - END (cimag); + END; } static const struct test_c_c_data clog_test_data[] = { - START_DATA (clog), TEST_c_c (clog, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION), TEST_c_c (clog, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION), @@ -6370,7 +6474,6 @@ static const struct test_c_c_data clog_test_data[] = TEST_c_c (clog, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 4.6017338806965821566734340588575402712716e-67L, 1.3547418904611758959096647942223384691728L), TEST_c_c (clog, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 2.5993421227864195179698176012564317527271e-67L, 1.4132318089683022770487383611430906982461L), #endif - END_DATA (clog) }; static void @@ -6378,13 +6481,12 @@ clog_test (void) { START (clog); RUN_TEST_LOOP_c_c (clog, clog_test_data, ); - END (clog, complex); + END_COMPLEX; } static const struct test_c_c_data clog10_test_data[] = { - START_DATA (clog10), TEST_c_c (clog10, minus_zero, 0, minus_infty, M_PIl, DIVIDE_BY_ZERO_EXCEPTION), TEST_c_c (clog10, minus_zero, minus_zero, minus_infty, -M_PIl, DIVIDE_BY_ZERO_EXCEPTION), @@ -6589,7 +6691,6 @@ static const struct test_c_c_data clog10_test_data[] = TEST_c_c (clog10, 0xdb85c467ee2aadd5f425fe0f4b8dp-114L, 0x3e83162a0f95f1dcbf97dddf410eap-114L, 1.9985076315737626043096596036300177494613e-67L, 0.5883569274304683249184005177865521205198L), TEST_c_c (clog10, 0x1415bcaf2105940d49a636e98ae59p-115L, 0x7e6a150adfcd1b0921d44b31f40f4p-115L, 1.1288799405048268615023706955013387413519e-67L, 0.6137587762850841972073301550420510507903L), #endif - END_DATA (clog10) }; static void @@ -6597,13 +6698,12 @@ clog10_test (void) { START (clog10); RUN_TEST_LOOP_c_c (clog10, clog10_test_data, ); - END (clog10, complex); + END_COMPLEX; } static const struct test_c_c_data conj_test_data[] = { - START_DATA (conj), TEST_c_c (conj, 0.0, 0.0, 0.0, minus_zero, NO_INEXACT_EXCEPTION), TEST_c_c (conj, 0.0, minus_zero, 0.0, 0.0, NO_INEXACT_EXCEPTION), TEST_c_c (conj, qnan_value, qnan_value, qnan_value, qnan_value, NO_INEXACT_EXCEPTION), @@ -6611,7 +6711,6 @@ static const struct test_c_c_data conj_test_data[] = TEST_c_c (conj, plus_infty, plus_infty, plus_infty, minus_infty, NO_INEXACT_EXCEPTION), TEST_c_c (conj, 1.0, 2.0, 1.0, -2.0, NO_INEXACT_EXCEPTION), TEST_c_c (conj, 3.0, -4.0, 3.0, 4.0, NO_INEXACT_EXCEPTION), - END_DATA (conj) }; static void @@ -6619,13 +6718,12 @@ conj_test (void) { START (conj); RUN_TEST_LOOP_c_c (conj, conj_test_data, ); - END (conj, complex); + END_COMPLEX; } static const struct test_ff_f_data copysign_test_data[] = { - START_DATA (copysign), TEST_ff_f (copysign, 0, 4, 0, NO_INEXACT_EXCEPTION), TEST_ff_f (copysign, 0, -4, minus_zero, NO_INEXACT_EXCEPTION), TEST_ff_f (copysign, minus_zero, 4, 0, NO_INEXACT_EXCEPTION), @@ -6646,7 +6744,6 @@ static const struct test_ff_f_data copysign_test_data[] = TEST_ff_f (copysign, qnan_value, minus_zero, qnan_value, NO_INEXACT_EXCEPTION), TEST_ff_f (copysign, -qnan_value, 0, qnan_value, NO_INEXACT_EXCEPTION), TEST_ff_f (copysign, -qnan_value, minus_zero, qnan_value, NO_INEXACT_EXCEPTION), - END_DATA (copysign) }; static void @@ -6654,13 +6751,12 @@ copysign_test (void) { START (copysign); RUN_TEST_LOOP_ff_f (copysign, copysign_test_data, ); - END (copysign); + END; } static const struct test_f_f_data cos_test_data[] = { - START_DATA (cos), TEST_f_f (cos, 0, 1), TEST_f_f (cos, minus_zero, 1), TEST_f_f (cos, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM), @@ -6721,7 +6817,6 @@ static const struct test_f_f_data cos_test_data[] = TEST_f_f (cos, 0x1.fffffep+127, 8.53021039830304158051791467692161107353094e-01L), TEST_f_f (cos, 0x1p+50, 8.68095904660550604334592502063501320395739e-01L), TEST_f_f (cos, 0x1p+28, -1.65568979490578758865468278195361551113358e-01L), - END_DATA (cos) }; static void @@ -6729,13 +6824,12 @@ cos_test (void) { START (cos); RUN_TEST_LOOP_f_f (cos, cos_test_data, ); - END (cos); + END; } static const struct test_f_f_data cos_tonearest_test_data[] = { - START_DATA (cos_tonearest), TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L), TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L), TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L), @@ -6746,7 +6840,6 @@ static const struct test_f_f_data cos_tonearest_test_data[] = TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L), TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L), TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L), - END_DATA (cos_tonearest) }; static void @@ -6754,13 +6847,12 @@ cos_test_tonearest (void) { START (cos_tonearest); RUN_TEST_LOOP_f_f (cos, cos_tonearest_test_data, FE_TONEAREST); - END (cos_tonearest); + END; } static const struct test_f_f_data cos_towardzero_test_data[] = { - START_DATA (cos_towardzero), TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L), TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L), TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L), @@ -6771,7 +6863,6 @@ static const struct test_f_f_data cos_towardzero_test_data[] = TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L), TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L), TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L), - END_DATA (cos_towardzero) }; static void @@ -6779,13 +6870,12 @@ cos_test_towardzero (void) { START (cos_towardzero); RUN_TEST_LOOP_f_f (cos, cos_towardzero_test_data, FE_TOWARDZERO); - END (cos_towardzero); + END; } static const struct test_f_f_data cos_downward_test_data[] = { - START_DATA (cos_downward), TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L), TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L), TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L), @@ -6796,7 +6886,6 @@ static const struct test_f_f_data cos_downward_test_data[] = TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L), TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L), TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L), - END_DATA (cos_downward) }; static void @@ -6804,13 +6893,12 @@ cos_test_downward (void) { START (cos_downward); RUN_TEST_LOOP_f_f (cos, cos_downward_test_data, FE_DOWNWARD); - END (cos_downward); + END; } static const struct test_f_f_data cos_upward_test_data[] = { - START_DATA (cos_upward), TEST_f_f (cos, 1, 0.5403023058681397174009366074429766037323L), TEST_f_f (cos, 2, -0.4161468365471423869975682295007621897660L), TEST_f_f (cos, 3, -0.9899924966004454572715727947312613023937L), @@ -6821,7 +6909,6 @@ static const struct test_f_f_data cos_upward_test_data[] = TEST_f_f (cos, 8, -0.1455000338086135258688413818311946826093L), TEST_f_f (cos, 9, -0.9111302618846769883682947111811653112463L), TEST_f_f (cos, 10, -0.8390715290764524522588639478240648345199L), - END_DATA (cos_upward) }; static void @@ -6829,13 +6916,12 @@ cos_test_upward (void) { START (cos_upward); RUN_TEST_LOOP_f_f (cos, cos_upward_test_data, FE_UPWARD); - END (cos_upward); + END; } static const struct test_f_f_data cosh_test_data[] = { - START_DATA (cosh), TEST_f_f (cosh, 0, 1), TEST_f_f (cosh, minus_zero, 1), @@ -6851,7 +6937,6 @@ static const struct test_f_f_data cosh_test_data[] = TEST_f_f (cosh, 709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L), TEST_f_f (cosh, -709.8893558127259666434838436543941497802734375L, 9.9999998999995070652573675944761818416035e+307L), #endif - END_DATA (cosh) }; static void @@ -6859,17 +6944,15 @@ cosh_test (void) { START (cosh); RUN_TEST_LOOP_f_f (cosh, cosh_test_data, ); - END (cosh); + END; } static const struct test_f_f_data cosh_tonearest_test_data[] = { - START_DATA (cosh_tonearest), TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L), TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L), TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L), - END_DATA (cosh_tonearest) }; static void @@ -6877,17 +6960,15 @@ cosh_test_tonearest (void) { START (cosh_tonearest); RUN_TEST_LOOP_f_f (cosh, cosh_tonearest_test_data, FE_TONEAREST); - END (cosh_tonearest); + END; } static const struct test_f_f_data cosh_towardzero_test_data[] = { - START_DATA (cosh_towardzero), TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L), TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L), TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L), - END_DATA (cosh_towardzero) }; static void @@ -6895,17 +6976,15 @@ cosh_test_towardzero (void) { START (cosh_towardzero); RUN_TEST_LOOP_f_f (cosh, cosh_towardzero_test_data, FE_TOWARDZERO); - END (cosh_towardzero); + END; } static const struct test_f_f_data cosh_downward_test_data[] = { - START_DATA (cosh_downward), TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L), TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L), TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L), - END_DATA (cosh_downward) }; static void @@ -6913,17 +6992,15 @@ cosh_test_downward (void) { START (cosh_downward); RUN_TEST_LOOP_f_f (cosh, cosh_downward_test_data, FE_DOWNWARD); - END (cosh_downward); + END; } static const struct test_f_f_data cosh_upward_test_data[] = { - START_DATA (cosh_upward), TEST_f_f (cosh, 22, 1792456423.065795780980053377632656584997L), TEST_f_f (cosh, 23, 4872401723.124451300068625740569997090344L), TEST_f_f (cosh, 24, 13244561064.92173614708845674912733665919L), - END_DATA (cosh_upward) }; static void @@ -6931,17 +7008,18 @@ cosh_test_upward (void) { START (cosh_upward); RUN_TEST_LOOP_f_f (cosh, cosh_upward_test_data, FE_UPWARD); - END (cosh_upward); + END; } static const struct test_cc_c_data cpow_test_data[] = { - START_DATA (cpow), TEST_cc_c (cpow, 1, 0, 0, 0, 1.0, 0.0), TEST_cc_c (cpow, 2, 0, 10, 0, 1024.0, 0.0), - +#if 0 + /* Disabled until we fix bug 14473. */ TEST_cc_c (cpow, M_El, 0, 0, 2 * M_PIl, 1.0, 0.0), +#endif TEST_cc_c (cpow, 2, 3, 4, 0, -119.0, -120.0), TEST_cc_c (cpow, qnan_value, qnan_value, qnan_value, qnan_value, qnan_value, qnan_value), @@ -6950,7 +7028,6 @@ static const struct test_cc_c_data cpow_test_data[] = TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 1.0L, 0.0846958290317209430433805274189191353L, 0.513285749182902449043287190519090481L), TEST_cc_c (cpow, 0.75L, 1.25L, 1.0L, 0.0L, 0.75L, 1.25L), TEST_cc_c (cpow, 0.75L, 1.25L, 0.0L, 1.0L, 0.331825439177608832276067945276730566L, 0.131338600281188544930936345230903032L), - END_DATA (cpow) }; static void @@ -6958,13 +7035,12 @@ cpow_test (void) { START (cpow); RUN_TEST_LOOP_cc_c (cpow, cpow_test_data, ); - END (cpow, complex); + END_COMPLEX; } static const struct test_c_c_data cproj_test_data[] = { - START_DATA (cproj), TEST_c_c (cproj, 0.0, 0.0, 0.0, 0.0, NO_INEXACT_EXCEPTION), TEST_c_c (cproj, minus_zero, minus_zero, minus_zero, minus_zero, NO_INEXACT_EXCEPTION), TEST_c_c (cproj, 0.0, minus_zero, 0.0, minus_zero, NO_INEXACT_EXCEPTION), @@ -6979,7 +7055,6 @@ static const struct test_c_c_data cproj_test_data[] = TEST_c_c (cproj, 1.0, 0.0, 1.0, 0.0, NO_INEXACT_EXCEPTION), TEST_c_c (cproj, 2.0, 3.0, 2.0, 3.0, NO_INEXACT_EXCEPTION), - END_DATA (cproj) }; static void @@ -6987,13 +7062,12 @@ cproj_test (void) { START (cproj); RUN_TEST_LOOP_c_c (cproj, cproj_test_data, ); - END (cproj, complex); + END_COMPLEX; } static const struct test_c_f_data creal_test_data[] = { - START_DATA (creal); TEST_c_f (creal, 0.0, 1.0, 0.0, NO_INEXACT_EXCEPTION), TEST_c_f (creal, minus_zero, 1.0, minus_zero, NO_INEXACT_EXCEPTION), TEST_c_f (creal, qnan_value, 1.0, qnan_value, NO_INEXACT_EXCEPTION), @@ -7001,7 +7075,6 @@ static const struct test_c_f_data creal_test_data[] = TEST_c_f (creal, plus_infty, 1.0, plus_infty, NO_INEXACT_EXCEPTION), TEST_c_f (creal, minus_infty, 1.0, minus_infty, NO_INEXACT_EXCEPTION), TEST_c_f (creal, 2.0, 3.0, 2.0, NO_INEXACT_EXCEPTION), - END_DATA (creal); }; static void @@ -7009,12 +7082,11 @@ creal_test (void) { START (creal); RUN_TEST_LOOP_c_f (creal, creal_test_data, ); - END (creal); + END; } static const struct test_c_c_data csin_test_data[] = { - START_DATA (csin), TEST_c_c (csin, 0.0, 0.0, 0.0, 0.0), TEST_c_c (csin, minus_zero, 0.0, minus_zero, 0.0), TEST_c_c (csin, 0.0, minus_zero, 0, minus_zero), @@ -7101,7 +7173,6 @@ static const struct test_c_c_data csin_test_data[] = TEST_c_c (csin, min_subnorm_value, min_value, min_subnorm_value, min_value, UNDERFLOW_EXCEPTION), TEST_c_c (csin, min_value, min_subnorm_value, min_value, min_subnorm_value, UNDERFLOW_EXCEPTION), - END_DATA (csin) }; static void @@ -7109,13 +7180,12 @@ csin_test (void) { START (csin); RUN_TEST_LOOP_c_c (csin, csin_test_data, ); - END (csin, complex); + END_COMPLEX; } static const struct test_c_c_data csinh_test_data[] = { - START_DATA (csinh), TEST_c_c (csinh, 0.0, 0.0, 0.0, 0.0), TEST_c_c (csinh, minus_zero, 0.0, minus_zero, 0.0), TEST_c_c (csinh, 0.0, minus_zero, 0.0, minus_zero), @@ -7202,7 +7272,6 @@ static const struct test_c_c_data csinh_test_data[] = TEST_c_c (csinh, min_subnorm_value, min_value, min_subnorm_value, min_value, UNDERFLOW_EXCEPTION), TEST_c_c (csinh, min_value, min_subnorm_value, min_value, min_subnorm_value, UNDERFLOW_EXCEPTION), - END_DATA (csinh) }; static void @@ -7210,13 +7279,12 @@ csinh_test (void) { START (csinh); RUN_TEST_LOOP_c_c (csinh, csinh_test_data, ); - END (csinh, complex); + END_COMPLEX; } static const struct test_c_c_data csqrt_test_data[] = { - START_DATA (csqrt), TEST_c_c (csqrt, 0, 0, 0.0, 0.0), TEST_c_c (csqrt, 0, minus_zero, 0, minus_zero), TEST_c_c (csqrt, minus_zero, 0, 0.0, 0.0), @@ -7323,7 +7391,6 @@ static const struct test_c_c_data csqrt_test_data[] = TEST_c_c (csqrt, -0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-16382L, 8.344545284118961663847948339519226074126e-2467L, -2.014551439675644900022606748976158925145e-2466L), # endif #endif - END_DATA (csqrt) }; static void @@ -7331,12 +7398,11 @@ csqrt_test (void) { START (csqrt); RUN_TEST_LOOP_c_c (csqrt, csqrt_test_data, ); - END (csqrt, complex); + END_COMPLEX; } static const struct test_c_c_data ctan_test_data[] = { - START_DATA (ctan), TEST_c_c (ctan, 0, 0, 0.0, 0.0), TEST_c_c (ctan, 0, minus_zero, 0.0, minus_zero), TEST_c_c (ctan, minus_zero, 0, minus_zero, 0.0), @@ -7409,7 +7475,6 @@ static const struct test_c_c_data ctan_test_data[] = TEST_c_c (ctan, 50000, -50000, plus_zero, -1.0, UNDERFLOW_EXCEPTION), TEST_c_c (ctan, -50000, 50000, minus_zero, 1.0, UNDERFLOW_EXCEPTION), TEST_c_c (ctan, -50000, -50000, minus_zero, -1.0, UNDERFLOW_EXCEPTION), - END_DATA (ctan) }; static void @@ -7417,13 +7482,12 @@ ctan_test (void) { START (ctan); RUN_TEST_LOOP_c_c (ctan, ctan_test_data, ); - END (ctan, complex); + END_COMPLEX; } static const struct test_c_c_data ctan_tonearest_test_data[] = { - START_DATA (ctan_tonearest), TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L), #ifndef TEST_FLOAT @@ -7433,7 +7497,6 @@ static const struct test_c_c_data ctan_tonearest_test_data[] = #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L), #endif - END_DATA (ctan_tonearest) }; static void @@ -7441,13 +7504,12 @@ ctan_test_tonearest (void) { START (ctan_tonearest); RUN_TEST_LOOP_c_c (ctan, ctan_tonearest_test_data, FE_TONEAREST); - END (ctan_tonearest, complex); + END_COMPLEX; } static const struct test_c_c_data ctan_towardzero_test_data[] = { - START_DATA (ctan_towardzero), TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L), #ifndef TEST_FLOAT @@ -7457,7 +7519,6 @@ static const struct test_c_c_data ctan_towardzero_test_data[] = #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L), #endif - END_DATA (ctan_towardzero) }; static void @@ -7465,13 +7526,12 @@ ctan_test_towardzero (void) { START (ctan_towardzero); RUN_TEST_LOOP_c_c (ctan, ctan_towardzero_test_data, FE_TOWARDZERO); - END (ctan_towardzero, complex); + END_COMPLEX; } static const struct test_c_c_data ctan_downward_test_data[] = { - START_DATA (ctan_downward), TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L), #ifndef TEST_FLOAT @@ -7481,7 +7541,6 @@ static const struct test_c_c_data ctan_downward_test_data[] = #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L), #endif - END_DATA (ctan_downward) }; static void @@ -7489,13 +7548,12 @@ ctan_test_downward (void) { START (ctan_downward); RUN_TEST_LOOP_c_c (ctan, ctan_downward_test_data, FE_DOWNWARD); - END (ctan_downward, complex); + END_COMPLEX; } static const struct test_c_c_data ctan_upward_test_data[] = { - START_DATA (ctan_upward), TEST_c_c (ctan, 0x1.921fb6p+0, 0x1p-149, -2.287733242885645987394874673945769518150e7L, 7.334008549954377778731880988481078535821e-31L), #ifndef TEST_FLOAT @@ -7505,7 +7563,6 @@ static const struct test_c_c_data ctan_upward_test_data[] = #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 TEST_c_c (ctan, 0x1.921fb54442d1846ap+0L, 0x1p-16445L, -3.986797629811710706723242948653362815645e19L, 5.793882568875674066286163141055208625180e-4912L), #endif - END_DATA (ctan_upward) }; static void @@ -7513,13 +7570,12 @@ ctan_test_upward (void) { START (ctan_upward); RUN_TEST_LOOP_c_c (ctan, ctan_upward_test_data, FE_UPWARD); - END (ctan_upward, complex); + END_COMPLEX; } static const struct test_c_c_data ctanh_test_data[] = { - START_DATA (ctanh), TEST_c_c (ctanh, 0, 0, 0.0, 0.0), TEST_c_c (ctanh, 0, minus_zero, 0.0, minus_zero), TEST_c_c (ctanh, minus_zero, 0, minus_zero, 0.0), @@ -7593,7 +7649,6 @@ static const struct test_c_c_data ctanh_test_data[] = TEST_c_c (ctanh, 50000, -50000, 1.0, minus_zero, UNDERFLOW_EXCEPTION), TEST_c_c (ctanh, -50000, 50000, -1.0, plus_zero, UNDERFLOW_EXCEPTION), TEST_c_c (ctanh, -50000, -50000, -1.0, minus_zero, UNDERFLOW_EXCEPTION), - END_DATA (ctanh) }; static void @@ -7601,13 +7656,12 @@ ctanh_test (void) { START (ctanh); RUN_TEST_LOOP_c_c (ctanh, ctanh_test_data, ); - END (ctanh, complex); + END_COMPLEX; } static const struct test_c_c_data ctanh_tonearest_test_data[] = { - START_DATA (ctanh_tonearest), TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L), #ifndef TEST_FLOAT @@ -7617,7 +7671,6 @@ static const struct test_c_c_data ctanh_tonearest_test_data[] = #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L), #endif - END_DATA (ctanh_tonearest) }; static void @@ -7625,13 +7678,12 @@ ctanh_test_tonearest (void) { START (ctanh_tonearest); RUN_TEST_LOOP_c_c (ctanh, ctanh_tonearest_test_data, FE_TONEAREST); - END (ctanh_tonearest, complex); + END_COMPLEX; } static const struct test_c_c_data ctanh_towardzero_test_data[] = { - START_DATA (ctanh_towardzero), TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L), #ifndef TEST_FLOAT @@ -7641,7 +7693,6 @@ static const struct test_c_c_data ctanh_towardzero_test_data[] = #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L), #endif - END_DATA (ctanh_towardzero) }; static void @@ -7649,13 +7700,12 @@ ctanh_test_towardzero (void) { START (ctanh_towardzero); RUN_TEST_LOOP_c_c (ctanh, ctanh_towardzero_test_data, FE_TOWARDZERO); - END (ctanh_towardzero, complex); + END_COMPLEX; } static const struct test_c_c_data ctanh_downward_test_data[] = { - START_DATA (ctanh_downward), TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L), #ifndef TEST_FLOAT @@ -7665,7 +7715,6 @@ static const struct test_c_c_data ctanh_downward_test_data[] = #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L), #endif - END_DATA (ctanh_downward) }; static void @@ -7673,13 +7722,12 @@ ctanh_test_downward (void) { START (ctanh_downward); RUN_TEST_LOOP_c_c (ctanh, ctanh_downward_test_data, FE_DOWNWARD); - END (ctanh_downward, complex); + END_COMPLEX; } static const struct test_c_c_data ctanh_upward_test_data[] = { - START_DATA (ctanh_upward), TEST_c_c (ctanh, 0x1p-149, 0x1.921fb6p+0, 7.334008549954377778731880988481078535821e-31L, -2.287733242885645987394874673945769518150e7L), #ifndef TEST_FLOAT @@ -7689,7 +7737,6 @@ static const struct test_c_c_data ctanh_upward_test_data[] = #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 TEST_c_c (ctanh, 0x1p-16445L, 0x1.921fb54442d1846ap+0L, 5.793882568875674066286163141055208625180e-4912L, -3.986797629811710706723242948653362815645e19L), #endif - END_DATA (ctanh_upward) }; static void @@ -7697,13 +7744,12 @@ ctanh_test_upward (void) { START (ctanh_upward); RUN_TEST_LOOP_c_c (ctanh, ctanh_upward_test_data, FE_UPWARD); - END (ctanh_upward, complex); + END_COMPLEX; } static const struct test_f_f_data erf_test_data[] = { - START_DATA (erf), TEST_f_f (erf, 0, 0), TEST_f_f (erf, minus_zero, minus_zero), TEST_f_f (erf, plus_infty, 1), @@ -7716,7 +7762,6 @@ static const struct test_f_f_data erf_test_data[] = TEST_f_f (erf, 2.0L, 0.995322265018952734162069256367252929L), TEST_f_f (erf, 4.125L, 0.999999994576599200434933994687765914L), TEST_f_f (erf, 27.0L, 1.0L), - END_DATA (erf) }; static void @@ -7724,13 +7769,12 @@ erf_test (void) { START (erf); RUN_TEST_LOOP_f_f (erf, erf_test_data, ); - END (erf); + END; } static const struct test_f_f_data erfc_test_data[] = { - START_DATA (erfc), TEST_f_f (erfc, plus_infty, 0.0), TEST_f_f (erfc, minus_infty, 2.0), TEST_f_f (erfc, 0.0, 1.0), @@ -7754,7 +7798,6 @@ static const struct test_f_f_data erfc_test_data[] = TEST_f_f (erfc, 0x1.ffff56789abcdef0123456789a8p+2L, 1.123161416304655390092138725253789378459e-29L), # endif #endif - END_DATA (erfc) }; static void @@ -7762,13 +7805,12 @@ erfc_test (void) { START (erfc); RUN_TEST_LOOP_f_f (erfc, erfc_test_data, ); - END (erfc); + END; } static const struct test_f_f_data exp_test_data[] = { - START_DATA (exp), TEST_f_f (exp, 0, 1), TEST_f_f (exp, minus_zero, 1), @@ -7799,7 +7841,6 @@ static const struct test_f_f_data exp_test_data[] = TEST_f_f (exp, 1e5, plus_infty, OVERFLOW_EXCEPTION|ERRNO_ERANGE), TEST_f_f (exp, max_value, plus_infty, OVERFLOW_EXCEPTION|ERRNO_ERANGE), TEST_f_f (exp, -max_value, 0, UNDERFLOW_EXCEPTION), - END_DATA (exp) }; static void @@ -7807,17 +7848,15 @@ exp_test (void) { START (exp); RUN_TEST_LOOP_f_f (exp, exp_test_data, ); - END (exp); + END; } static const struct test_f_f_data exp_tonearest_test_data[] = { - START_DATA (exp_tonearest), TEST_f_f (exp, 1, M_El), TEST_f_f (exp, 2, M_E2l), TEST_f_f (exp, 3, M_E3l), - END_DATA (exp_tonearest) }; static void @@ -7825,17 +7864,15 @@ exp_test_tonearest (void) { START (exp_tonearest); RUN_TEST_LOOP_f_f (exp, exp_tonearest_test_data, FE_TONEAREST); - END (exp_tonearest); + END; } static const struct test_f_f_data exp_towardzero_test_data[] = { - START_DATA (exp_towardzero), TEST_f_f (exp, 1, M_El), TEST_f_f (exp, 2, M_E2l), TEST_f_f (exp, 3, M_E3l), - END_DATA (exp_towardzero) }; static void @@ -7843,17 +7880,15 @@ exp_test_towardzero (void) { START (exp_towardzero); RUN_TEST_LOOP_f_f (exp, exp_towardzero_test_data, FE_TOWARDZERO); - END (exp_towardzero); + END; } static const struct test_f_f_data exp_downward_test_data[] = { - START_DATA (exp_downward), TEST_f_f (exp, 1, M_El), TEST_f_f (exp, 2, M_E2l), TEST_f_f (exp, 3, M_E3l), - END_DATA (exp_downward) }; static void @@ -7861,17 +7896,15 @@ exp_test_downward (void) { START (exp_downward); RUN_TEST_LOOP_f_f (exp, exp_downward_test_data, FE_DOWNWARD); - END (exp_downward); + END; } static const struct test_f_f_data exp_upward_test_data[] = { - START_DATA (exp_upward), TEST_f_f (exp, 1, M_El), TEST_f_f (exp, 2, M_E2l), TEST_f_f (exp, 3, M_E3l), - END_DATA (exp_upward) }; static void @@ -7879,13 +7912,12 @@ exp_test_upward (void) { START (exp_upward); RUN_TEST_LOOP_f_f (exp, exp_upward_test_data, FE_UPWARD); - END (exp_upward); + END; } static const struct test_f_f_data exp10_test_data[] = { - START_DATA (exp10), TEST_f_f (exp10, 0, 1), TEST_f_f (exp10, minus_zero, 1), @@ -7909,7 +7941,6 @@ static const struct test_f_f_data exp10_test_data[] = TEST_f_f (exp10, max_value, plus_infty, OVERFLOW_EXCEPTION|ERRNO_ERANGE), TEST_f_f (exp10, -max_value, 0, UNDERFLOW_EXCEPTION), TEST_f_f (exp10, 0.75L, 5.62341325190349080394951039776481231L), - END_DATA (exp10) }; static void @@ -7917,13 +7948,21 @@ exp10_test (void) { START (exp10); RUN_TEST_LOOP_f_f (exp10, exp10_test_data, ); - END (exp10); + END; +} + +static void +pow10_test (void) +{ + START (pow10); + /* pow10 uses the same test data as exp10. */ + RUN_TEST_LOOP_f_f (pow10, exp10_test_data, ); + END; } static const struct test_f_f_data exp2_test_data[] = { - START_DATA (exp2), TEST_f_f (exp2, 0, 1), TEST_f_f (exp2, minus_zero, 1), TEST_f_f (exp2, plus_infty, plus_infty), @@ -7952,7 +7991,6 @@ static const struct test_f_f_data exp2_test_data[] = TEST_f_f (exp2, 16383, 0x1p16383L), TEST_f_f (exp2, -16400, 0x1p-16400L), #endif - END_DATA (exp2) }; static void @@ -7960,13 +7998,12 @@ exp2_test (void) { START (exp2); RUN_TEST_LOOP_f_f (exp2, exp2_test_data, ); - END (exp2); + END; } static const struct test_f_f_data expm1_test_data[] = { - START_DATA (expm1), TEST_f_f (expm1, 0, 0), TEST_f_f (expm1, minus_zero, minus_zero), @@ -8014,7 +8051,6 @@ static const struct test_f_f_data expm1_test_data[] = TEST_f_f (expm1, 100000.0, plus_infty, OVERFLOW_EXCEPTION|ERRNO_ERANGE), TEST_f_f (expm1, max_value, plus_infty, OVERFLOW_EXCEPTION|ERRNO_ERANGE), TEST_f_f (expm1, -max_value, -1), - END_DATA (expm1) }; static void @@ -8022,13 +8058,12 @@ expm1_test (void) { START (expm1); RUN_TEST_LOOP_f_f (expm1, expm1_test_data, ); - END (expm1); + END; } static const struct test_f_f_data fabs_test_data[] = { - START_DATA (fabs), TEST_f_f (fabs, 0, 0, NO_INEXACT_EXCEPTION), TEST_f_f (fabs, minus_zero, 0, NO_INEXACT_EXCEPTION), @@ -8038,7 +8073,6 @@ static const struct test_f_f_data fabs_test_data[] = TEST_f_f (fabs, 38.0, 38.0, NO_INEXACT_EXCEPTION), TEST_f_f (fabs, -M_El, M_El, NO_INEXACT_EXCEPTION), - END_DATA (fabs) }; static void @@ -8046,13 +8080,12 @@ fabs_test (void) { START (fabs); RUN_TEST_LOOP_f_f (fabs, fabs_test_data, ); - END (fabs); + END; } static const struct test_ff_f_data fdim_test_data[] = { - START_DATA (fdim), TEST_ff_f (fdim, 0, 0, 0, NO_INEXACT_EXCEPTION), TEST_ff_f (fdim, 9, 0, 9, NO_INEXACT_EXCEPTION), TEST_ff_f (fdim, 0, 9, 0, NO_INEXACT_EXCEPTION), @@ -8080,7 +8113,6 @@ static const struct test_ff_f_data fdim_test_data[] = TEST_ff_f (fdim, qnan_value, qnan_value, qnan_value, NO_INEXACT_EXCEPTION), TEST_ff_f (fdim, plus_infty, plus_infty, 0, NO_INEXACT_EXCEPTION), - END_DATA (fdim) }; static void @@ -8088,35 +8120,12 @@ fdim_test (void) { START (fdim); RUN_TEST_LOOP_ff_f (fdim, fdim_test_data, ); - END (fdim); -} - - -static const struct test_f_i_data finite_test_data[] = - { - START_DATA (finite), - TEST_f_b (finite, 0, 1, NO_INEXACT_EXCEPTION), - TEST_f_b (finite, minus_zero, 1, NO_INEXACT_EXCEPTION), - TEST_f_b (finite, 10, 1, NO_INEXACT_EXCEPTION), - TEST_f_b (finite, min_subnorm_value, 1, NO_INEXACT_EXCEPTION), - TEST_f_b (finite, plus_infty, 0, NO_INEXACT_EXCEPTION), - TEST_f_b (finite, minus_infty, 0, NO_INEXACT_EXCEPTION), - TEST_f_b (finite, qnan_value, 0, NO_INEXACT_EXCEPTION), - END_DATA (finite) - }; - -static void -finite_test (void) -{ - START (finite); - RUN_TEST_LOOP_f_b (finite, finite_test_data, ); - END (finite); + END; } static const struct test_f_f_data floor_test_data[] = { - START_DATA (floor), TEST_f_f (floor, 0.0, 0.0, NO_INEXACT_EXCEPTION), TEST_f_f (floor, minus_zero, minus_zero, NO_INEXACT_EXCEPTION), TEST_f_f (floor, plus_infty, plus_infty, NO_INEXACT_EXCEPTION), @@ -8209,7 +8218,6 @@ static const struct test_f_f_data floor_test_data[] = TEST_f_f (floor, 0xf.ffffffffffffff8p+47L, 0xf.fffffffffffep+47L), TEST_f_f (floor, -0x8.000000000000004p+48L, -0x8.000000000001p+48L), #endif - END_DATA (floor) }; static void @@ -8217,13 +8225,12 @@ floor_test (void) { START (floor); RUN_TEST_LOOP_f_f (floor, floor_test_data, ); - END (floor); + END; } static const struct test_fff_f_data fma_test_data[] = { - START_DATA (fma), TEST_fff_f (fma, 1.0, 2.0, 3.0, 5.0), TEST_fff_f (fma, qnan_value, 2.0, 3.0, qnan_value), TEST_fff_f (fma, 1.0, qnan_value, 3.0, qnan_value), @@ -8503,7 +8510,6 @@ static const struct test_fff_f_data fma_test_data[] = TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L), TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L), #endif - END_DATA (fma) }; static void @@ -8511,13 +8517,12 @@ fma_test (void) { START (fma); RUN_TEST_LOOP_fff_f (fma, fma_test_data, ); - END (fma); + END; } static const struct test_fff_f_data fma_towardzero_test_data[] = { - START_DATA (fma_towardzero), TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero), TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero), TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero), @@ -8720,7 +8725,6 @@ static const struct test_fff_f_data fma_towardzero_test_data[] = TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x0.ffffffffffffffffffffffffffff8p16319L), TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L), #endif - END_DATA (fma_towardzero) }; static void @@ -8728,13 +8732,12 @@ fma_test_towardzero (void) { START (fma_towardzero); RUN_TEST_LOOP_fff_f (fma, fma_towardzero_test_data, FE_TOWARDZERO); - END (fma_towardzero); + END; } static const struct test_fff_f_data fma_downward_test_data[] = { - START_DATA (fma_downward), TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero), TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, minus_zero), TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, minus_zero), @@ -8937,7 +8940,6 @@ static const struct test_fff_f_data fma_downward_test_data[] = TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L), TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1.0000000000000000000000000001p16319L), #endif - END_DATA (fma_downward) }; static void @@ -8945,13 +8947,12 @@ fma_test_downward (void) { START (fma_downward); RUN_TEST_LOOP_fff_f (fma, fma_downward_test_data, FE_DOWNWARD); - END (fma_downward); + END; } static const struct test_fff_f_data fma_upward_test_data[] = { - START_DATA (fma_upward), TEST_fff_f (fma, plus_zero, plus_zero, plus_zero, plus_zero), TEST_fff_f (fma, plus_zero, plus_zero, minus_zero, plus_zero), TEST_fff_f (fma, plus_zero, minus_zero, plus_zero, plus_zero), @@ -9154,7 +9155,6 @@ static const struct test_fff_f_data fma_upward_test_data[] = TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, 0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x0.ffffffffffffffffffffffffffff8p16319L), TEST_fff_f (fma, 0x1.0000000000000000000000000001p-16382L, -0x1.0000000000000000000000000001p-66L, -0x1p16319L, -0x1p16319L), #endif - END_DATA (fma_upward) }; static void @@ -9162,13 +9162,12 @@ fma_test_upward (void) { START (fma_upward); RUN_TEST_LOOP_fff_f (fma, fma_upward_test_data, FE_UPWARD); - END (fma_upward); + END; } static const struct test_ff_f_data fmax_test_data[] = { - START_DATA (fmax), TEST_ff_f (fmax, 0, 0, 0, NO_INEXACT_EXCEPTION), TEST_ff_f (fmax, minus_zero, minus_zero, minus_zero, NO_INEXACT_EXCEPTION), TEST_ff_f (fmax, 9, 0, 9, NO_INEXACT_EXCEPTION), @@ -9197,7 +9196,6 @@ static const struct test_ff_f_data fmax_test_data[] = TEST_ff_f (fmax, qnan_value, plus_infty, plus_infty, NO_INEXACT_EXCEPTION), TEST_ff_f (fmax, qnan_value, minus_infty, minus_infty, NO_INEXACT_EXCEPTION), TEST_ff_f (fmax, qnan_value, qnan_value, qnan_value, NO_INEXACT_EXCEPTION), - END_DATA (fmax) }; static void @@ -9205,13 +9203,12 @@ fmax_test (void) { START (fmax); RUN_TEST_LOOP_ff_f (fmax, fmax_test_data, ); - END (fmax); + END; } static const struct test_ff_f_data fmin_test_data[] = { - START_DATA (fmin), TEST_ff_f (fmin, 0, 0, 0, NO_INEXACT_EXCEPTION), TEST_ff_f (fmin, minus_zero, minus_zero, minus_zero, NO_INEXACT_EXCEPTION), TEST_ff_f (fmin, 9, 0, 0, NO_INEXACT_EXCEPTION), @@ -9239,7 +9236,6 @@ static const struct test_ff_f_data fmin_test_data[] = TEST_ff_f (fmin, qnan_value, plus_infty, plus_infty, NO_INEXACT_EXCEPTION), TEST_ff_f (fmin, qnan_value, minus_infty, minus_infty, NO_INEXACT_EXCEPTION), TEST_ff_f (fmin, qnan_value, qnan_value, qnan_value, NO_INEXACT_EXCEPTION), - END_DATA (fmin) }; static void @@ -9247,13 +9243,12 @@ fmin_test (void) { START (fmin); RUN_TEST_LOOP_ff_f (fmin, fmin_test_data, ); - END (fmin); + END; } static const struct test_ff_f_data fmod_test_data[] = { - START_DATA (fmod), /* fmod (+0, y) == +0 for y != 0. */ TEST_ff_f (fmod, 0, 3, 0, NO_INEXACT_EXCEPTION), @@ -9288,7 +9283,6 @@ static const struct test_ff_f_data fmod_test_data[] = #if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 TEST_ff_f (fmod, 0x0.fffffffffffffffep-16382L, 0x1p-16445L, plus_zero, NO_INEXACT_EXCEPTION), #endif - END_DATA (fmod) }; static void @@ -9296,13 +9290,12 @@ fmod_test (void) { START (fmod); RUN_TEST_LOOP_ff_f (fmod, fmod_test_data, ); - END (fmod); + END; } static const struct test_f_i_data fpclassify_test_data[] = { - START_DATA (fpclassify), TEST_f_i (fpclassify, qnan_value, FP_NAN, NO_INEXACT_EXCEPTION), TEST_f_i (fpclassify, plus_infty, FP_INFINITE, NO_INEXACT_EXCEPTION), TEST_f_i (fpclassify, minus_infty, FP_INFINITE, NO_INEXACT_EXCEPTION), @@ -9310,7 +9303,6 @@ static const struct test_f_i_data fpclassify_test_data[] = TEST_f_i (fpclassify, minus_zero, FP_ZERO, NO_INEXACT_EXCEPTION), TEST_f_i (fpclassify, 1000, FP_NORMAL, NO_INEXACT_EXCEPTION), TEST_f_i (fpclassify, min_subnorm_value, FP_SUBNORMAL, NO_INEXACT_EXCEPTION), - END_DATA (fpclassify) }; static void @@ -9318,13 +9310,12 @@ fpclassify_test (void) { START (fpclassify); RUN_TEST_LOOP_f_i_tg (fpclassify, fpclassify_test_data, ); - END (fpclassify); + END; } static const struct test_f_f1_data frexp_test_data[] = { - START_DATA (frexp), TEST_fI_f1 (frexp, plus_infty, plus_infty, IGNORE, NO_INEXACT_EXCEPTION), TEST_fI_f1 (frexp, minus_infty, minus_infty, IGNORE, NO_INEXACT_EXCEPTION), TEST_fI_f1 (frexp, qnan_value, qnan_value, IGNORE, NO_INEXACT_EXCEPTION), @@ -9334,7 +9325,6 @@ static const struct test_f_f1_data frexp_test_data[] = TEST_fI_f1 (frexp, 12.8L, 0.8L, 4, NO_INEXACT_EXCEPTION), TEST_fI_f1 (frexp, -27.34L, -0.854375L, 5, NO_INEXACT_EXCEPTION), - END_DATA (frexp) }; static void @@ -9344,38 +9334,11 @@ frexp_test (void) START (frexp); RUN_TEST_LOOP_fI_f1 (frexp, frexp_test_data, , x); - END (frexp); -} - - -static const struct test_f_f1_data gamma_test_data[] = - { - START_DATA (gamma), - TEST_f_f1 (gamma, plus_infty, plus_infty, 1), - TEST_f_f1 (gamma, 0, plus_infty, 1, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), - TEST_f_f1 (gamma, -3, plus_infty, IGNORE, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), - TEST_f_f1 (gamma, minus_infty, plus_infty, IGNORE), - TEST_f_f1 (gamma, qnan_value, qnan_value, IGNORE), - - TEST_f_f1 (gamma, 1, 0, 1), - TEST_f_f1 (gamma, 3, M_LN2l, 1), - - TEST_f_f1 (gamma, 0.5, M_LOG_SQRT_PIl, 1), - TEST_f_f1 (gamma, -0.5, M_LOG_2_SQRT_PIl, -1), - END_DATA (gamma) - }; - -static void -gamma_test (void) -{ - START (gamma); - RUN_TEST_LOOP_f_f1 (gamma, gamma_test_data, , signgam); - END (gamma); + END; } static const struct test_ff_f_data hypot_test_data[] = { - START_DATA (hypot), TEST_ff_f (hypot, plus_infty, 1, plus_infty), TEST_ff_f (hypot, minus_infty, 1, plus_infty), @@ -9424,7 +9387,19 @@ static const struct test_ff_f_data hypot_test_data[] = #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 && !defined TEST_INLINE TEST_ff_f (hypot, 0x3p16381L, 0x4p16381L, 0x5p16381L), #endif - END_DATA (hypot) + + TEST_ff_f (hypot, 0x1p-149L, 0x1p-149L, 1.9817352931807469938024533350782879785095e-45L, UNDERFLOW_EXCEPTION_FLOAT), + +#ifndef TEST_FLOAT + TEST_ff_f (hypot, 0x1p-1074L, 0x1p-1074L, 6.9871433705131320800651344656990806305791e-324L, UNDERFLOW_EXCEPTION_DOUBLE), +#endif + +#if defined TEST_LDOUBLE && LDBL_MIN_EXP <= -16381 && !defined TEST_INLINE + TEST_ff_f (hypot, 0x1p-16445L, 0x1p-16445L, 5.1550906155442528702558159159596215039925e-4951L, UNDERFLOW_EXCEPTION), +# if LDBL_MANT_DIG >= 113 + TEST_ff_f (hypot, 0x1p-16494L, 0x1p-16494L, 9.1572804726500807075521065242888978445857e-4966L, UNDERFLOW_EXCEPTION), +# endif +#endif }; static void @@ -9432,13 +9407,12 @@ hypot_test (void) { START (hypot); RUN_TEST_LOOP_ff_f (hypot, hypot_test_data, ); - END (hypot); + END; } static const struct test_f_i_data ilogb_test_data[] = { - START_DATA (ilogb), TEST_f_i (ilogb, 1, 0, NO_INEXACT_EXCEPTION), TEST_f_i (ilogb, M_El, 1, NO_INEXACT_EXCEPTION), TEST_f_i (ilogb, 1024, 10, NO_INEXACT_EXCEPTION), @@ -9452,7 +9426,6 @@ static const struct test_f_i_data ilogb_test_data[] = TEST_f_i (ilogb, plus_infty, INT_MAX, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), /* ilogb (-inf) == INT_MAX plus invalid exception */ TEST_f_i (ilogb, minus_infty, INT_MAX, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), - END_DATA (ilogb) }; static void @@ -9460,12 +9433,11 @@ ilogb_test (void) { START (ilogb); RUN_TEST_LOOP_f_i (ilogb, ilogb_test_data, ); - END (ilogb); + END; } static const struct test_f_i_data isfinite_test_data[] = { - START_DATA (isfinite), TEST_f_b (isfinite, 0, 1, NO_INEXACT_EXCEPTION), TEST_f_b (isfinite, minus_zero, 1, NO_INEXACT_EXCEPTION), TEST_f_b (isfinite, 10, 1, NO_INEXACT_EXCEPTION), @@ -9473,7 +9445,6 @@ static const struct test_f_i_data isfinite_test_data[] = TEST_f_b (isfinite, plus_infty, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isfinite, minus_infty, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isfinite, qnan_value, 0, NO_INEXACT_EXCEPTION), - END_DATA (isfinite) }; static void @@ -9481,12 +9452,20 @@ isfinite_test (void) { START (isfinite); RUN_TEST_LOOP_f_b_tg (isfinite, isfinite_test_data, ); - END (isfinite); + END; +} + +static void +finite_test (void) +{ + START (finite); + /* finite uses the same test data as isfinite. */ + RUN_TEST_LOOP_f_b (finite, isfinite_test_data, ); + END; } static const struct test_ff_i_data isgreater_test_data[] = { - START_DATA (isgreater), TEST_ff_i (isgreater, minus_zero, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isgreater, minus_zero, plus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isgreater, minus_zero, (FLOAT) 1, 0, NO_INEXACT_EXCEPTION), @@ -9503,7 +9482,6 @@ static const struct test_ff_i_data isgreater_test_data[] = TEST_ff_i (isgreater, qnan_value, plus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isgreater, qnan_value, (FLOAT) 1, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isgreater, qnan_value, qnan_value, 0, NO_INEXACT_EXCEPTION), - END_DATA (isgreater) }; static void @@ -9511,12 +9489,11 @@ isgreater_test (void) { START (isgreater); RUN_TEST_LOOP_ff_i_tg (isgreater, isgreater_test_data, ); - END (isgreater); + END; } static const struct test_ff_i_data isgreaterequal_test_data[] = { - START_DATA (isgreaterequal), TEST_ff_i (isgreaterequal, minus_zero, minus_zero, 1, NO_INEXACT_EXCEPTION), TEST_ff_i (isgreaterequal, minus_zero, plus_zero, 1, NO_INEXACT_EXCEPTION), TEST_ff_i (isgreaterequal, minus_zero, (FLOAT) 1, 0, NO_INEXACT_EXCEPTION), @@ -9533,7 +9510,6 @@ static const struct test_ff_i_data isgreaterequal_test_data[] = TEST_ff_i (isgreaterequal, qnan_value, plus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isgreaterequal, qnan_value, (FLOAT) 1, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isgreaterequal, qnan_value, qnan_value, 0, NO_INEXACT_EXCEPTION), - END_DATA (isgreaterequal) }; static void @@ -9541,12 +9517,11 @@ isgreaterequal_test (void) { START (isgreaterequal); RUN_TEST_LOOP_ff_i_tg (isgreaterequal, isgreaterequal_test_data, ); - END (isgreaterequal); + END; } static const struct test_f_i_data isinf_test_data[] = { - START_DATA (isinf), TEST_f_b (isinf, 0, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isinf, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isinf, 10, 0, NO_INEXACT_EXCEPTION), @@ -9554,7 +9529,6 @@ static const struct test_f_i_data isinf_test_data[] = TEST_f_b (isinf, plus_infty, 1, NO_INEXACT_EXCEPTION), TEST_f_b (isinf, minus_infty, 1, NO_INEXACT_EXCEPTION), TEST_f_b (isinf, qnan_value, 0, NO_INEXACT_EXCEPTION), - END_DATA (isinf) }; static void @@ -9562,12 +9536,11 @@ isinf_test (void) { START (isinf); RUN_TEST_LOOP_f_b_tg (isinf, isinf_test_data, ); - END (isinf); + END; } static const struct test_ff_i_data isless_test_data[] = { - START_DATA (isless), TEST_ff_i (isless, minus_zero, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isless, minus_zero, plus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isless, minus_zero, (FLOAT) 1, 1, NO_INEXACT_EXCEPTION), @@ -9584,7 +9557,6 @@ static const struct test_ff_i_data isless_test_data[] = TEST_ff_i (isless, qnan_value, plus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isless, qnan_value, (FLOAT) 1, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isless, qnan_value, qnan_value, 0, NO_INEXACT_EXCEPTION), - END_DATA (isless) }; static void @@ -9592,12 +9564,11 @@ isless_test (void) { START (isless); RUN_TEST_LOOP_ff_i_tg (isless, isless_test_data, ); - END (isless); + END; } static const struct test_ff_i_data islessequal_test_data[] = { - START_DATA (islessequal), TEST_ff_i (islessequal, minus_zero, minus_zero, 1, NO_INEXACT_EXCEPTION), TEST_ff_i (islessequal, minus_zero, plus_zero, 1, NO_INEXACT_EXCEPTION), TEST_ff_i (islessequal, minus_zero, (FLOAT) 1, 1, NO_INEXACT_EXCEPTION), @@ -9614,7 +9585,6 @@ static const struct test_ff_i_data islessequal_test_data[] = TEST_ff_i (islessequal, qnan_value, plus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (islessequal, qnan_value, (FLOAT) 1, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (islessequal, qnan_value, qnan_value, 0, NO_INEXACT_EXCEPTION), - END_DATA (islessequal) }; static void @@ -9622,12 +9592,11 @@ islessequal_test (void) { START (islessequal); RUN_TEST_LOOP_ff_i_tg (islessequal, islessequal_test_data, ); - END (islessequal); + END; } static const struct test_ff_i_data islessgreater_test_data[] = { - START_DATA (islessgreater), TEST_ff_i (islessgreater, minus_zero, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (islessgreater, minus_zero, plus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (islessgreater, minus_zero, (FLOAT) 1, 1, NO_INEXACT_EXCEPTION), @@ -9644,7 +9613,6 @@ static const struct test_ff_i_data islessgreater_test_data[] = TEST_ff_i (islessgreater, qnan_value, plus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (islessgreater, qnan_value, (FLOAT) 1, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (islessgreater, qnan_value, qnan_value, 0, NO_INEXACT_EXCEPTION), - END_DATA (islessgreater) }; static void @@ -9652,12 +9620,11 @@ islessgreater_test (void) { START (islessgreater); RUN_TEST_LOOP_ff_i_tg (islessgreater, islessgreater_test_data, ); - END (islessgreater); + END; } static const struct test_f_i_data isnan_test_data[] = { - START_DATA (isnan), TEST_f_b (isnan, 0, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isnan, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isnan, 10, 0, NO_INEXACT_EXCEPTION), @@ -9665,7 +9632,6 @@ static const struct test_f_i_data isnan_test_data[] = TEST_f_b (isnan, plus_infty, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isnan, minus_infty, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isnan, qnan_value, 1, NO_INEXACT_EXCEPTION), - END_DATA (isnan) }; static void @@ -9673,12 +9639,11 @@ isnan_test (void) { START (isnan); RUN_TEST_LOOP_f_b_tg (isnan, isnan_test_data, ); - END (isnan); + END; } static const struct test_f_i_data isnormal_test_data[] = { - START_DATA (isnormal), TEST_f_b (isnormal, 0, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isnormal, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isnormal, 10, 1, NO_INEXACT_EXCEPTION), @@ -9686,7 +9651,6 @@ static const struct test_f_i_data isnormal_test_data[] = TEST_f_b (isnormal, plus_infty, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isnormal, minus_infty, 0, NO_INEXACT_EXCEPTION), TEST_f_b (isnormal, qnan_value, 0, NO_INEXACT_EXCEPTION), - END_DATA (isnormal) }; static void @@ -9694,12 +9658,11 @@ isnormal_test (void) { START (isnormal); RUN_TEST_LOOP_f_b_tg (isnormal, isnormal_test_data, ); - END (isnormal); + END; } static const struct test_f_i_data issignaling_test_data[] = { - START_DATA (issignaling), TEST_f_b (issignaling, 0, 0, NO_INEXACT_EXCEPTION), TEST_f_b (issignaling, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_b (issignaling, 10, 0, NO_INEXACT_EXCEPTION), @@ -9707,7 +9670,6 @@ static const struct test_f_i_data issignaling_test_data[] = TEST_f_b (issignaling, plus_infty, 0, NO_INEXACT_EXCEPTION), TEST_f_b (issignaling, minus_infty, 0, NO_INEXACT_EXCEPTION), TEST_f_b (issignaling, qnan_value, 0, NO_INEXACT_EXCEPTION), - END_DATA (issignaling) }; static void @@ -9715,12 +9677,11 @@ issignaling_test (void) { START (issignaling); RUN_TEST_LOOP_f_b_tg (issignaling, issignaling_test_data, ); - END (issignaling); + END; } static const struct test_ff_i_data isunordered_test_data[] = { - START_DATA (isunordered), TEST_ff_i (isunordered, minus_zero, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isunordered, minus_zero, plus_zero, 0, NO_INEXACT_EXCEPTION), TEST_ff_i (isunordered, minus_zero, (FLOAT) 1, 0, NO_INEXACT_EXCEPTION), @@ -9737,7 +9698,6 @@ static const struct test_ff_i_data isunordered_test_data[] = TEST_ff_i (isunordered, qnan_value, plus_zero, 1, NO_INEXACT_EXCEPTION), TEST_ff_i (isunordered, qnan_value, (FLOAT) 1, 1, NO_INEXACT_EXCEPTION), TEST_ff_i (isunordered, qnan_value, qnan_value, 1, NO_INEXACT_EXCEPTION), - END_DATA (isunordered) }; static void @@ -9745,12 +9705,11 @@ isunordered_test (void) { START (isunordered); RUN_TEST_LOOP_ff_i_tg (isunordered, isunordered_test_data, ); - END (isunordered); + END; } static const struct test_f_f_data j0_test_data[] = { - START_DATA (j0), /* j0 is the Bessel function of the first kind of order 0 */ TEST_f_f (j0, qnan_value, qnan_value), TEST_f_f (j0, plus_infty, 0), @@ -9777,7 +9736,6 @@ static const struct test_f_f_data j0_test_data[] = TEST_f_f (j0, 0x1p16382L, -1.2193782500509000574176799046642541129387e-2466L), TEST_f_f (j0, 0x1p16383L, 9.5859502826270374691362975419147645151233e-2467L), #endif - END_DATA (j0) }; static void @@ -9785,13 +9743,12 @@ j0_test (void) { START (j0); RUN_TEST_LOOP_f_f (j0, j0_test_data, ); - END (j0); + END; } static const struct test_f_f_data j1_test_data[] = { - START_DATA (j1), /* j1 is the Bessel function of the first kind of order 1 */ TEST_f_f (j1, qnan_value, qnan_value), TEST_f_f (j1, plus_infty, 0), @@ -9817,7 +9774,6 @@ static const struct test_f_f_data j1_test_data[] = TEST_f_f (j1, 0x1p16382L, 8.0839224448726336195866026476176740513439e-2467L), TEST_f_f (j1, 0x1p16383L, -3.8895531955766020648617743624167352352217e-2467L), #endif - END_DATA (j1) }; static void @@ -9825,12 +9781,11 @@ j1_test (void) { START (j1); RUN_TEST_LOOP_f_f (j1, j1_test_data, ); - END (j1); + END; } static const struct test_if_f_data jn_test_data[] = { - START_DATA (jn), /* jn is the Bessel function of the first kind of order n. */ /* jn (0, x) == j0 (x) */ TEST_if_f (jn, 0, qnan_value, qnan_value), @@ -9896,7 +9851,6 @@ static const struct test_if_f_data jn_test_data[] = /* Bug 14155: spurious exception may occur. */ TEST_if_f (jn, 2, 0x1.ffff62p+99L, -4.43860668048170034334926693188979974489e-16L, UNDERFLOW_EXCEPTION_OK), - END_DATA (jn) }; static void @@ -9904,13 +9858,12 @@ jn_test (void) { START (jn); RUN_TEST_LOOP_if_f (jn, jn_test_data, ); - END (jn); + END; } static const struct test_fi_f_data ldexp_test_data[] = { - START_DATA (ldexp), TEST_fi_f (ldexp, 0, 0, 0, NO_INEXACT_EXCEPTION), TEST_fi_f (ldexp, minus_zero, 0, minus_zero, NO_INEXACT_EXCEPTION), @@ -9923,7 +9876,6 @@ static const struct test_fi_f_data ldexp_test_data[] = /* ldexp (x, 0) == x. */ TEST_fi_f (ldexp, 1.0L, 0L, 1.0L, NO_INEXACT_EXCEPTION), - END_DATA (ldexp) }; static void @@ -9931,13 +9883,12 @@ ldexp_test (void) { START (ldexp); RUN_TEST_LOOP_fi_f (ldexp, ldexp_test_data, ); - END (ldexp); + END; } static const struct test_f_f1_data lgamma_test_data[] = { - START_DATA (lgamma), TEST_f_f1 (lgamma, plus_infty, plus_infty, 1), TEST_f_f1 (lgamma, 0, plus_infty, 1, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), TEST_f_f1 (lgamma, minus_zero, plus_infty, -1, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), @@ -9957,7 +9908,6 @@ static const struct test_f_f1_data lgamma_test_data[] = TEST_f_f1 (lgamma, -0.5, M_LOG_2_SQRT_PIl, -1), TEST_f_f1 (lgamma, 0.7L, 0.260867246531666514385732417016759578L, 1), TEST_f_f1 (lgamma, 1.2L, -0.853740900033158497197028392998854470e-1L, 1), - END_DATA (lgamma) }; static void @@ -9965,13 +9915,21 @@ lgamma_test (void) { START (lgamma); RUN_TEST_LOOP_f_f1 (lgamma, lgamma_test_data, , signgam); - END (lgamma); + END; +} + +static void +gamma_test (void) +{ + START (gamma); + /* gamma uses the same test data as lgamma. */ + RUN_TEST_LOOP_f_f1 (gamma, lgamma_test_data, , signgam); + END; } static const struct test_f_l_data lrint_test_data[] = { - START_DATA (lrint), /* XXX this test is incomplete. We need to have a way to specifiy the rounding method and test the critical cases. So far, only unproblematic numbers are tested. */ @@ -9994,7 +9952,6 @@ static const struct test_f_l_data lrint_test_data[] = TEST_f_l (lrint, 281474976710656.025L, 281474976710656, INEXACT_EXCEPTION), # endif #endif - END_DATA (lrint) }; static void @@ -10002,13 +9959,12 @@ lrint_test (void) { START (lrint); RUN_TEST_LOOP_f_l (lrint, lrint_test_data, ); - END (lrint); + END; } static const struct test_f_l_data lrint_tonearest_test_data[] = { - START_DATA (lrint_tonearest), TEST_f_l (lrint, 0.0, 0, NO_INEXACT_EXCEPTION), TEST_f_l (lrint, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_l (lrint, 0.2L, 0, INEXACT_EXCEPTION), @@ -10031,7 +9987,6 @@ static const struct test_f_l_data lrint_tonearest_test_data[] = TEST_f_l (lrint, 281474976710656.025L, 281474976710656, INEXACT_EXCEPTION), # endif #endif - END_DATA (lrint_tonearest) }; static void @@ -10039,13 +9994,12 @@ lrint_test_tonearest (void) { START (lrint_tonearest); RUN_TEST_LOOP_f_l (lrint, lrint_tonearest_test_data, FE_TONEAREST); - END (lrint_tonearest); + END; } static const struct test_f_l_data lrint_towardzero_test_data[] = { - START_DATA (lrint_towardzero), TEST_f_l (lrint, 0.0, 0, NO_INEXACT_EXCEPTION), TEST_f_l (lrint, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_l (lrint, 0.2L, 0, INEXACT_EXCEPTION), @@ -10068,7 +10022,6 @@ static const struct test_f_l_data lrint_towardzero_test_data[] = TEST_f_l (lrint, 281474976710656.025L, 281474976710656, INEXACT_EXCEPTION), # endif #endif - END_DATA (lrint_towardzero) }; static void @@ -10076,13 +10029,12 @@ lrint_test_towardzero (void) { START (lrint_towardzero); RUN_TEST_LOOP_f_l (lrint, lrint_towardzero_test_data, FE_TOWARDZERO); - END (lrint_towardzero); + END; } static const struct test_f_l_data lrint_downward_test_data[] = { - START_DATA (lrint_downward), TEST_f_l (lrint, 0.0, 0, NO_INEXACT_EXCEPTION), TEST_f_l (lrint, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_l (lrint, 0.2L, 0, INEXACT_EXCEPTION), @@ -10105,7 +10057,6 @@ static const struct test_f_l_data lrint_downward_test_data[] = TEST_f_l (lrint, 281474976710656.025L, 281474976710656, INEXACT_EXCEPTION), # endif #endif - END_DATA (lrint_downward) }; static void @@ -10113,13 +10064,12 @@ lrint_test_downward (void) { START (lrint_downward); RUN_TEST_LOOP_f_l (lrint, lrint_downward_test_data, FE_DOWNWARD); - END (lrint_downward); + END; } static const struct test_f_l_data lrint_upward_test_data[] = { - START_DATA (lrint_upward), TEST_f_l (lrint, 0.0, 0, NO_INEXACT_EXCEPTION), TEST_f_l (lrint, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_l (lrint, 0.2L, 1, INEXACT_EXCEPTION), @@ -10142,7 +10092,6 @@ static const struct test_f_l_data lrint_upward_test_data[] = TEST_f_l (lrint, 281474976710656.025L, 281474976710657, INEXACT_EXCEPTION), # endif #endif - END_DATA (lrint_upward) }; static void @@ -10150,13 +10099,12 @@ lrint_test_upward (void) { START (lrint_upward); RUN_TEST_LOOP_f_l (lrint, lrint_upward_test_data, FE_UPWARD); - END (lrint_upward); + END; } static const struct test_f_L_data llrint_test_data[] = { - START_DATA (llrint), /* XXX this test is incomplete. We need to have a way to specifiy the rounding method and test the critical cases. So far, only unproblematic numbers are tested. */ @@ -10284,7 +10232,6 @@ static const struct test_f_L_data llrint_test_data[] = TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL, NO_INEXACT_EXCEPTION), # endif #endif - END_DATA (llrint) }; static void @@ -10292,12 +10239,11 @@ llrint_test (void) { START (llrint); RUN_TEST_LOOP_f_L (llrint, llrint_test_data, ); - END (llrint); + END; } static const struct test_f_L_data llrint_tonearest_test_data[] = { - START_DATA (llrint_tonearest), TEST_f_L (llrint, 0.0, 0, NO_INEXACT_EXCEPTION), TEST_f_L (llrint, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_L (llrint, 0.2L, 0, INEXACT_EXCEPTION), @@ -10421,7 +10367,6 @@ static const struct test_f_L_data llrint_tonearest_test_data[] = TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL, NO_INEXACT_EXCEPTION), # endif #endif - END_DATA (llrint_tonearest) }; static void @@ -10429,12 +10374,11 @@ llrint_test_tonearest (void) { START (llrint_tonearest); RUN_TEST_LOOP_f_L (llrint, llrint_tonearest_test_data, FE_TONEAREST); - END (llrint_tonearest); + END; } static const struct test_f_L_data llrint_towardzero_test_data[] = { - START_DATA (llrint_towardzero), TEST_f_L (llrint, 0.0, 0, NO_INEXACT_EXCEPTION), TEST_f_L (llrint, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_L (llrint, 0.2L, 0, INEXACT_EXCEPTION), @@ -10558,7 +10502,6 @@ static const struct test_f_L_data llrint_towardzero_test_data[] = TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL, NO_INEXACT_EXCEPTION), # endif #endif - END_DATA (llrint_towardzero) }; static void @@ -10566,12 +10509,11 @@ llrint_test_towardzero (void) { START (llrint_towardzero); RUN_TEST_LOOP_f_L (llrint, llrint_towardzero_test_data, FE_TOWARDZERO); - END (llrint_towardzero); + END; } static const struct test_f_L_data llrint_downward_test_data[] = { - START_DATA (llrint_downward), TEST_f_L (llrint, 0.0, 0, NO_INEXACT_EXCEPTION), TEST_f_L (llrint, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_L (llrint, 0.2L, 0, INEXACT_EXCEPTION), @@ -10691,7 +10633,6 @@ static const struct test_f_L_data llrint_downward_test_data[] = TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL, NO_INEXACT_EXCEPTION), # endif #endif - END_DATA (llrint_downward) }; static void @@ -10699,12 +10640,11 @@ llrint_test_downward (void) { START (llrint_downward); RUN_TEST_LOOP_f_L (llrint, llrint_downward_test_data, FE_DOWNWARD); - END (llrint_downward); + END; } static const struct test_f_L_data llrint_upward_test_data[] = { - START_DATA (llrint_upward), TEST_f_L (llrint, 0.0, 0, NO_INEXACT_EXCEPTION), TEST_f_L (llrint, minus_zero, 0, NO_INEXACT_EXCEPTION), TEST_f_L (llrint, 0.2L, 1, INEXACT_EXCEPTION), @@ -10822,7 +10762,6 @@ static const struct test_f_L_data llrint_upward_test_data[] = TEST_f_L (llrint, -9223372036854775807.0L, -9223372036854775807LL, NO_INEXACT_EXCEPTION), # endif #endif - END_DATA (llrint_upward) }; static void @@ -10830,13 +10769,12 @@ llrint_test_upward (void) { START (llrint_upward); RUN_TEST_LOOP_f_L (llrint, llrint_upward_test_data, FE_UPWARD); - END (llrint_upward); + END; } static const struct test_f_f_data log_test_data[] = { - START_DATA (log), TEST_f_f (log, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), TEST_f_f (log, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), @@ -10853,7 +10791,6 @@ static const struct test_f_f_data log_test_data[] = TEST_f_f (log, 2, M_LN2l), TEST_f_f (log, 10, M_LN10l), TEST_f_f (log, 0.75L, -0.287682072451780927439219005993827432L), - END_DATA (log) }; static void @@ -10861,13 +10798,12 @@ log_test (void) { START (log); RUN_TEST_LOOP_f_f (log, log_test_data, ); - END (log); + END; } static const struct test_f_f_data log10_test_data[] = { - START_DATA (log10), TEST_f_f (log10, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), TEST_f_f (log10, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), @@ -10887,7 +10823,6 @@ static const struct test_f_f_data log10_test_data[] = TEST_f_f (log10, 10000.0, 4), TEST_f_f (log10, M_El, M_LOG10El), TEST_f_f (log10, 0.75L, -0.124938736608299953132449886193870744L), - END_DATA (log10) }; static void @@ -10895,13 +10830,12 @@ log10_test (void) { START (log10); RUN_TEST_LOOP_f_f (log10, log10_test_data, ); - END (log10); + END; } static const struct test_f_f_data log1p_test_data[] = { - START_DATA (log1p), TEST_f_f (log1p, 0, 0), TEST_f_f (log1p, minus_zero, minus_zero), @@ -10917,7 +10851,6 @@ static const struct test_f_f_data log1p_test_data[] = TEST_f_f (log1p, -0.25L, -0.287682072451780927439219005993827432L), TEST_f_f (log1p, -0.875, -2.07944154167983592825169636437452970L), - END_DATA (log1p) }; static void @@ -10925,13 +10858,12 @@ log1p_test (void) { START (log1p); RUN_TEST_LOOP_f_f (log1p, log1p_test_data, ); - END (log1p); + END; } static const struct test_f_f_data log2_test_data[] = { - START_DATA (log2), TEST_f_f (log2, 0, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), TEST_f_f (log2, minus_zero, minus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), @@ -10949,7 +10881,6 @@ static const struct test_f_f_data log2_test_data[] = TEST_f_f (log2, 16.0, 4), TEST_f_f (log2, 256.0, 8), TEST_f_f (log2, 0.75L, -.415037499278843818546261056052183492L), - END_DATA (log2) }; static void @@ -10957,13 +10888,12 @@ log2_test (void) { START (log2); RUN_TEST_LOOP_f_f (log2, log2_test_data, ); - END (log2); + END; } static const struct test_f_f_data logb_test_data[] = { - START_DATA (logb), TEST_f_f (logb, plus_infty, plus_infty, NO_INEXACT_EXCEPTION), TEST_f_f (logb, minus_infty, plus_infty, NO_INEXACT_EXCEPTION), @@ -10992,7 +10922,6 @@ static const struct test_f_f_data logb_test_data[] = TEST_f_f (logb, 0x1p-16400L, -16400, NO_INEXACT_EXCEPTION), TEST_f_f (logb, 0x.00000000001p-16382L, -16426, NO_INEXACT_EXCEPTION), #endif - END_DATA (logb) }; static void @@ -11000,12 +10929,11 @@ logb_test (void) { START (logb); RUN_TEST_LOOP_f_f (logb, logb_test_data, ); - END (logb); + END; } static const struct test_f_f_data logb_downward_test_data[] = { - START_DATA (logb_downward), /* IEEE 754-2008 says (section 5.3.3) that "logB(1) is +0.". Libm should not return -0 from logb in any rounding mode. PowerPC32 has failed with this test for power4 logb (and logbl on all PowerPC @@ -11016,7 +10944,6 @@ static const struct test_f_f_data logb_downward_test_data[] = /* BZ #887 */ TEST_f_f (logb, 1.000e+0, plus_zero, NO_INEXACT_EXCEPTION), - END_DATA (logb_downward) }; static void @@ -11024,12 +10951,11 @@ logb_test_downward (void) { START (logb_downward); RUN_TEST_LOOP_f_f (logb, logb_downward_test_data, FE_DOWNWARD); - END (logb_downward); + END; } static const struct test_f_l_data lround_test_data[] = { - START_DATA (lround), /* TODO: missing +/-Inf as well as qNaN tests. */ TEST_f_l (lround, 0, 0), TEST_f_l (lround, minus_zero, 0), @@ -11064,7 +10990,6 @@ static const struct test_f_l_data lround_test_data[] = TEST_f_l (lround, 0x1.fffffep+23, 16777215), TEST_f_l (lround, -0x1.fffffep+23, -16777215), #endif - END_DATA (lround) }; static void @@ -11072,13 +10997,12 @@ lround_test (void) { START (lround); RUN_TEST_LOOP_f_l (lround, lround_test_data, ); - END (lround); + END; } static const struct test_f_L_data llround_test_data[] = { - START_DATA (llround), /* TODO: missing +/-Inf as well as qNaN tests. */ TEST_f_L (llround, 0, 0), TEST_f_L (llround, minus_zero, 0), @@ -11241,7 +11165,6 @@ static const struct test_f_L_data llround_test_data[] = TEST_f_L (llround, 9223372036854775807.0L, 9223372036854775807LL), TEST_f_L (llround, -9223372036854775807.0L, -9223372036854775807LL), #endif - END_DATA (llround) }; static void @@ -11249,12 +11172,11 @@ llround_test (void) { START (llround); RUN_TEST_LOOP_f_L (llround, llround_test_data, ); - END (llround); + END; } static const struct test_fF_f1_data modf_test_data[] = { - START_DATA (modf), TEST_fF_f1 (modf, plus_infty, 0, plus_infty, NO_INEXACT_EXCEPTION), TEST_fF_f1 (modf, minus_infty, minus_zero, minus_infty, NO_INEXACT_EXCEPTION), TEST_fF_f1 (modf, qnan_value, qnan_value, qnan_value, NO_INEXACT_EXCEPTION), @@ -11265,7 +11187,6 @@ static const struct test_fF_f1_data modf_test_data[] = TEST_fF_f1 (modf, 20, 0, 20, NO_INEXACT_EXCEPTION), TEST_fF_f1 (modf, 21, 0, 21, NO_INEXACT_EXCEPTION), TEST_fF_f1 (modf, 89.5, 0.5, 89, NO_INEXACT_EXCEPTION), - END_DATA (modf) }; static void @@ -11275,14 +11196,12 @@ modf_test (void) START (modf); RUN_TEST_LOOP_fF_f1 (modf, modf_test_data, , x); - END (modf); + END; } static const struct test_f_f_data nearbyint_test_data[] = { - START_DATA (nearbyint), - TEST_f_f (nearbyint, 0.0, 0.0, NO_INEXACT_EXCEPTION), TEST_f_f (nearbyint, minus_zero, minus_zero, NO_INEXACT_EXCEPTION), TEST_f_f (nearbyint, plus_infty, plus_infty, NO_INEXACT_EXCEPTION), @@ -11326,8 +11245,6 @@ static const struct test_f_f_data nearbyint_test_data[] = TEST_f_f (nearbyint, -562949953421312.75, -562949953421313.0, NO_INEXACT_EXCEPTION), TEST_f_f (nearbyint, -1125899906842624.75, -1125899906842625.0, NO_INEXACT_EXCEPTION), #endif - - END_DATA (nearbyint) }; static void @@ -11335,13 +11252,11 @@ nearbyint_test (void) { START (nearbyint); RUN_TEST_LOOP_f_f (nearbyint, nearbyint_test_data, ); - END (nearbyint); + END; } static const struct test_ff_f_data nextafter_test_data[] = { - START_DATA (nextafter), - TEST_ff_f (nextafter, 0, 0, 0, NO_INEXACT_EXCEPTION), TEST_ff_f (nextafter, minus_zero, 0, 0, NO_INEXACT_EXCEPTION), TEST_ff_f (nextafter, 0, minus_zero, minus_zero, NO_INEXACT_EXCEPTION), @@ -11366,7 +11281,6 @@ static const struct test_ff_f_data nextafter_test_data[] = /* XXX We need the hexadecimal FP number representation here for further tests. */ - END_DATA (nextafter) }; static void @@ -11375,13 +11289,12 @@ nextafter_test (void) START (nextafter); RUN_TEST_LOOP_ff_f (nextafter, nextafter_test_data, ); - END (nextafter); + END; } static const struct test_ff_f_data_nexttoward nexttoward_test_data[] = { - START_DATA (nexttoward), TEST_ff_f (nexttoward, 0, 0, 0, NO_INEXACT_EXCEPTION), TEST_ff_f (nexttoward, minus_zero, 0, 0, NO_INEXACT_EXCEPTION), TEST_ff_f (nexttoward, 0, minus_zero, minus_zero, NO_INEXACT_EXCEPTION), @@ -11463,7 +11376,6 @@ static const struct test_ff_f_data_nexttoward nexttoward_test_data[] = TEST_ff_f (nexttoward, -1.0, -0x0.ffffffffffffffffffffffffffff8p0L, -0x0.fffffffffffff8p0, NO_INEXACT_EXCEPTION), # endif #endif - END_DATA (nexttoward) }; static void @@ -11471,13 +11383,12 @@ nexttoward_test (void) { START (nexttoward); RUN_TEST_LOOP_ff_f (nexttoward, nexttoward_test_data, ); - END (nexttoward); + END; } static const struct test_ff_f_data pow_test_data[] = { - START_DATA (pow), TEST_ff_f (pow, 0, 0, 1), TEST_ff_f (pow, 0, minus_zero, 1), TEST_ff_f (pow, minus_zero, 0, 1), @@ -12175,7 +12086,6 @@ static const struct test_ff_f_data pow_test_data[] = TEST_ff_f (pow, 1.01L, -min_subnorm_value, 1.0L), TEST_ff_f (pow, 2.0L, -100000.0L, plus_zero, UNDERFLOW_EXCEPTION), - END_DATA (pow) }; static void @@ -12184,16 +12094,14 @@ pow_test (void) START (pow); RUN_TEST_LOOP_ff_f (pow, pow_test_data, ); - END (pow); + END; } static const struct test_ff_f_data pow_tonearest_test_data[] = { - START_DATA (pow_tonearest), TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L), TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L), - END_DATA (pow_tonearest) }; static void @@ -12201,16 +12109,14 @@ pow_test_tonearest (void) { START (pow_tonearest); RUN_TEST_LOOP_ff_f (pow, pow_tonearest_test_data, FE_TONEAREST); - END (pow_tonearest); + END; } static const struct test_ff_f_data pow_towardzero_test_data[] = { - START_DATA (pow_towardzero), TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L), TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L), - END_DATA (pow_towardzero) }; static void @@ -12218,16 +12124,14 @@ pow_test_towardzero (void) { START (pow_towardzero); RUN_TEST_LOOP_ff_f (pow, pow_towardzero_test_data, FE_TOWARDZERO); - END (pow_towardzero); + END; } static const struct test_ff_f_data pow_downward_test_data[] = { - START_DATA (pow_downward), TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L), TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L), - END_DATA (pow_downward) }; static void @@ -12235,16 +12139,14 @@ pow_test_downward (void) { START (pow_downward); RUN_TEST_LOOP_ff_f (pow, pow_downward_test_data, FE_DOWNWARD); - END (pow_downward); + END; } static const struct test_ff_f_data pow_upward_test_data[] = { - START_DATA (pow_upward), TEST_ff_f (pow, 1.0625L, 1.125L, 1.070582293028761362162622578677070098674L), TEST_ff_f (pow, 1.5L, 1.03125L, 1.519127098714743184071644334163037684948L), - END_DATA (pow_upward) }; static void @@ -12252,13 +12154,12 @@ pow_test_upward (void) { START (pow_upward); RUN_TEST_LOOP_ff_f (pow, pow_upward_test_data, FE_UPWARD); - END (pow_upward); + END; } static const struct test_ff_f_data remainder_test_data[] = { - START_DATA (remainder), TEST_ff_f (remainder, 1, 0, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), TEST_ff_f (remainder, 1, minus_zero, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), TEST_ff_f (remainder, plus_infty, minus_zero, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), @@ -12282,7 +12183,6 @@ static const struct test_ff_f_data remainder_test_data[] = TEST_ff_f (remainder, -1.625, -1.0, 0.375, NO_INEXACT_EXCEPTION), TEST_ff_f (remainder, 5.0, 2.0, 1.0, NO_INEXACT_EXCEPTION), TEST_ff_f (remainder, 3.0, 2.0, -1.0, NO_INEXACT_EXCEPTION), - END_DATA (remainder) }; static void @@ -12290,13 +12190,21 @@ remainder_test (void) { START (remainder); RUN_TEST_LOOP_ff_f (remainder, remainder_test_data, ); - END (remainder); + END; +} + +static void +drem_test (void) +{ + START (drem); + /* drem uses the same test data as remainder. */ + RUN_TEST_LOOP_ff_f (drem, remainder_test_data, ); + END; } static const struct test_ff_f_data remainder_tonearest_test_data[] = { - START_DATA (remainder_tonearest), TEST_ff_f (remainder, 1, 0, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), TEST_ff_f (remainder, 1, minus_zero, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), TEST_ff_f (remainder, plus_infty, minus_zero, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), @@ -12320,7 +12228,6 @@ static const struct test_ff_f_data remainder_tonearest_test_data[] = TEST_ff_f (remainder, -1.625, -1.0, 0.375, NO_INEXACT_EXCEPTION), TEST_ff_f (remainder, 5.0, 2.0, 1.0, NO_INEXACT_EXCEPTION), TEST_ff_f (remainder, 3.0, 2.0, -1.0, NO_INEXACT_EXCEPTION), - END_DATA (remainder_tonearest) }; static void @@ -12328,13 +12235,21 @@ remainder_test_tonearest (void) { START (remainder_tonearest); RUN_TEST_LOOP_ff_f (remainder, remainder_tonearest_test_data, FE_TONEAREST); - END (remainder_tonearest); + END; +} + +static void +drem_test_tonearest (void) +{ + START (drem_tonearest); + /* drem uses the same test data as remainder. */ + RUN_TEST_LOOP_ff_f (drem, remainder_tonearest_test_data, FE_TONEAREST); + END; } static const struct test_ff_f_data remainder_towardzero_test_data[] = { - START_DATA (remainder_towardzero), TEST_ff_f (remainder, 1, 0, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), TEST_ff_f (remainder, 1, minus_zero, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), TEST_ff_f (remainder, plus_infty, minus_zero, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), @@ -12358,7 +12273,6 @@ static const struct test_ff_f_data remainder_towardzero_test_data[] = TEST_ff_f (remainder, -1.625, -1.0, 0.375, NO_INEXACT_EXCEPTION), TEST_ff_f (remainder, 5.0, 2.0, 1.0, NO_INEXACT_EXCEPTION), TEST_ff_f (remainder, 3.0, 2.0, -1.0, NO_INEXACT_EXCEPTION), - END_DATA (remainder_towardzero) }; static void @@ -12366,13 +12280,21 @@ remainder_test_towardzero (void) { START (remainder_towardzero); RUN_TEST_LOOP_ff_f (remainder, remainder_towardzero_test_data, FE_TOWARDZERO); - END (remainder_towardzero); + END; +} + +static void +drem_test_towardzero (void) +{ + START (drem_towardzero); + /* drem uses the same test data as remainder. */ + RUN_TEST_LOOP_ff_f (drem, remainder_towardzero_test_data, FE_TOWARDZERO); + END; } static const struct test_ff_f_data remainder_downward_test_data[] = { - START_DATA (remainder_downward), TEST_ff_f (remainder, 1, 0, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), TEST_ff_f (remainder, 1, minus_zero, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), TEST_ff_f (remainder, plus_infty, minus_zero, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), @@ -12396,7 +12318,6 @@ static const struct test_ff_f_data remainder_downward_test_data[] = TEST_ff_f (remainder, -1.625, -1.0, 0.375, NO_INEXACT_EXCEPTION), TEST_ff_f (remainder, 5.0, 2.0, 1.0, NO_INEXACT_EXCEPTION), TEST_ff_f (remainder, 3.0, 2.0, -1.0, NO_INEXACT_EXCEPTION), - END_DATA (remainder_downward) }; static void @@ -12404,13 +12325,21 @@ remainder_test_downward (void) { START (remainder_downward); RUN_TEST_LOOP_ff_f (remainder, remainder_downward_test_data, FE_DOWNWARD); - END (remainder_downward); + END; +} + +static void +drem_test_downward (void) +{ + START (drem_downward); + /* drem uses the same test data as remainder. */ + RUN_TEST_LOOP_ff_f (drem, remainder_downward_test_data, FE_DOWNWARD); + END; } static const struct test_ff_f_data remainder_upward_test_data[] = { - START_DATA (remainder_upward), TEST_ff_f (remainder, 1, 0, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), TEST_ff_f (remainder, 1, minus_zero, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), TEST_ff_f (remainder, plus_infty, minus_zero, qnan_value, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION|ERRNO_EDOM), @@ -12434,7 +12363,6 @@ static const struct test_ff_f_data remainder_upward_test_data[] = TEST_ff_f (remainder, -1.625, -1.0, 0.375, NO_INEXACT_EXCEPTION), TEST_ff_f (remainder, 5.0, 2.0, 1.0, NO_INEXACT_EXCEPTION), TEST_ff_f (remainder, 3.0, 2.0, -1.0, NO_INEXACT_EXCEPTION), - END_DATA (remainder_upward) }; static void @@ -12442,12 +12370,20 @@ remainder_test_upward (void) { START (remainder_upward); RUN_TEST_LOOP_ff_f (remainder, remainder_upward_test_data, FE_UPWARD); - END (remainder_upward); + END; +} + +static void +drem_test_upward (void) +{ + START (drem_upward); + /* drem uses the same test data as remainder. */ + RUN_TEST_LOOP_ff_f (drem, remainder_upward_test_data, FE_UPWARD); + END; } static const struct test_ffI_f1_data remquo_test_data[] = { - START_DATA (remquo), TEST_ffI_f1 (remquo, 1, 0, qnan_value, IGNORE, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION), TEST_ffI_f1 (remquo, 1, minus_zero, qnan_value, IGNORE, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION), TEST_ffI_f1 (remquo, plus_infty, 1, qnan_value, IGNORE, NO_INEXACT_EXCEPTION|INVALID_EXCEPTION), @@ -12461,7 +12397,6 @@ static const struct test_ffI_f1_data remquo_test_data[] = TEST_ffI_f1 (remquo, 5, 2, 1, 2, NO_INEXACT_EXCEPTION), TEST_ffI_f1 (remquo, 3, 2, -1, 2, NO_INEXACT_EXCEPTION), - END_DATA (remquo) }; static void @@ -12472,12 +12407,11 @@ remquo_test (void) START (remquo); RUN_TEST_LOOP_ffI_f1 (remquo, remquo_test_data, , x); - END (remquo); + END; } static const struct test_f_f_data rint_test_data[] = { - START_DATA (rint), /* TODO: missing qNaN tests. */ TEST_f_f (rint, 0.0, 0.0, NO_INEXACT_EXCEPTION), @@ -12594,7 +12528,6 @@ static const struct test_f_f_data rint_test_data[] = TEST_f_f (rint, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L, INEXACT_EXCEPTION), # endif #endif - END_DATA (rint) }; static void @@ -12602,12 +12535,11 @@ rint_test (void) { START (rint); RUN_TEST_LOOP_f_f (rint, rint_test_data, ); - END (rint); + END; } static const struct test_f_f_data rint_tonearest_test_data[] = { - START_DATA (rint_tonearest), TEST_f_f (rint, 2.0, 2.0, NO_INEXACT_EXCEPTION), TEST_f_f (rint, 1.5, 2.0, INEXACT_EXCEPTION), TEST_f_f (rint, 1.0, 1.0, NO_INEXACT_EXCEPTION), @@ -12677,7 +12609,6 @@ static const struct test_f_f_data rint_tonearest_test_data[] = TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L, INEXACT_EXCEPTION), # endif #endif - END_DATA (rint_tonearest) }; static void @@ -12685,12 +12616,11 @@ rint_test_tonearest (void) { START (rint_tonearest); RUN_TEST_LOOP_f_f (rint, rint_tonearest_test_data, FE_TONEAREST); - END (rint_tonearest); + END; } static const struct test_f_f_data rint_towardzero_test_data[] = { - START_DATA (rint_towardzero), TEST_f_f (rint, 2.0, 2.0, NO_INEXACT_EXCEPTION), TEST_f_f (rint, 1.5, 1.0, INEXACT_EXCEPTION), TEST_f_f (rint, 1.0, 1.0, NO_INEXACT_EXCEPTION), @@ -12760,7 +12690,6 @@ static const struct test_f_f_data rint_towardzero_test_data[] = TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L, INEXACT_EXCEPTION), # endif #endif - END_DATA (rint_towardzero) }; static void @@ -12768,12 +12697,11 @@ rint_test_towardzero (void) { START (rint_towardzero); RUN_TEST_LOOP_f_f (rint, rint_towardzero_test_data, FE_TOWARDZERO); - END (rint_towardzero); + END; } static const struct test_f_f_data rint_downward_test_data[] = { - START_DATA (rint_downward), TEST_f_f (rint, 2.0, 2.0, NO_INEXACT_EXCEPTION), TEST_f_f (rint, 1.5, 1.0, INEXACT_EXCEPTION), TEST_f_f (rint, 1.0, 1.0, NO_INEXACT_EXCEPTION), @@ -12843,7 +12771,6 @@ static const struct test_f_f_data rint_downward_test_data[] = TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740994.0L, INEXACT_EXCEPTION), # endif #endif - END_DATA (rint_downward) }; static void @@ -12851,12 +12778,11 @@ rint_test_downward (void) { START (rint_downward); RUN_TEST_LOOP_f_f (rint, rint_downward_test_data, FE_DOWNWARD); - END (rint_downward); + END; } static const struct test_f_f_data rint_upward_test_data[] = { - START_DATA (rint_upward), TEST_f_f (rint, 2.0, 2.0, NO_INEXACT_EXCEPTION), TEST_f_f (rint, 1.5, 2.0, INEXACT_EXCEPTION), TEST_f_f (rint, 1.0, 1.0, NO_INEXACT_EXCEPTION), @@ -12926,7 +12852,6 @@ static const struct test_f_f_data rint_upward_test_data[] = TEST_f_f (rint, -9007199254740993.5000000000001L, -9007199254740993.0L, INEXACT_EXCEPTION), # endif #endif - END_DATA (rint_upward) }; static void @@ -12934,12 +12859,11 @@ rint_test_upward (void) { START (rint_upward); RUN_TEST_LOOP_f_f (rint, rint_upward_test_data, FE_UPWARD); - END (rint_upward); + END; } static const struct test_f_f_data round_test_data[] = { - START_DATA (round), /* TODO: missing +/-Inf as well as qNaN tests. */ TEST_f_f (round, 0, 0, NO_INEXACT_EXCEPTION), @@ -13032,7 +12956,6 @@ static const struct test_f_f_data round_test_data[] = TEST_f_f (round, 10141204801825835211973625643008.75L, 10141204801825835211973625643009.0L), TEST_f_f (round, 10141204801825835211973625643009.5L, 10141204801825835211973625643010.0L), #endif - END_DATA (round) }; static void @@ -13040,13 +12963,12 @@ round_test (void) { START (round); RUN_TEST_LOOP_f_f (round, round_test_data, ); - END (round); + END; } static const struct test_ff_f_data scalb_test_data[] = { - START_DATA (scalb), TEST_ff_f (scalb, 2.0, 0.5, qnan_value, INVALID_EXCEPTION), TEST_ff_f (scalb, 3.0, -2.5, qnan_value, INVALID_EXCEPTION), @@ -13096,7 +13018,6 @@ static const struct test_ff_f_data scalb_test_data[] = TEST_ff_f (scalb, 0.8L, 4, 12.8L), TEST_ff_f (scalb, -0.854375L, 5, -27.34L), - END_DATA (scalb) }; static void @@ -13105,13 +13026,12 @@ scalb_test (void) START (scalb); RUN_TEST_LOOP_ff_f (scalb, scalb_test_data, ); - END (scalb); + END; } static const struct test_fi_f_data scalbn_test_data[] = { - START_DATA (scalbn), TEST_fi_f (scalbn, 0, 0, 0, NO_INEXACT_EXCEPTION), TEST_fi_f (scalbn, minus_zero, 0, minus_zero, NO_INEXACT_EXCEPTION), @@ -13132,7 +13052,6 @@ static const struct test_fi_f_data scalbn_test_data[] = TEST_fi_f (scalbn, min_value, INT_MIN, plus_zero, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION), TEST_fi_f (scalbn, min_value / 4, INT_MAX, plus_infty, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION), TEST_fi_f (scalbn, min_value / 4, INT_MIN, plus_zero, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION), - END_DATA (scalbn) }; static void @@ -13141,13 +13060,12 @@ scalbn_test (void) START (scalbn); RUN_TEST_LOOP_fi_f (scalbn, scalbn_test_data, ); - END (scalbn); + END; } static const struct test_fl_f_data scalbln_test_data[] = { - START_DATA (scalbln), TEST_fl_f (scalbln, 0, 0, 0, NO_INEXACT_EXCEPTION), TEST_fl_f (scalbln, minus_zero, 0, minus_zero, NO_INEXACT_EXCEPTION), @@ -13188,7 +13106,6 @@ static const struct test_fl_f_data scalbln_test_data[] = TEST_fl_f (scalbln, min_value / 4, 0x88000000L, plus_infty, INEXACT_EXCEPTION|OVERFLOW_EXCEPTION), TEST_fl_f (scalbln, min_value / 4, -0x88000000L, plus_zero, INEXACT_EXCEPTION|UNDERFLOW_EXCEPTION), #endif - END_DATA (scalbln) }; static void @@ -13197,13 +13114,12 @@ scalbln_test (void) START (scalbln); RUN_TEST_LOOP_fl_f (scalbln, scalbln_test_data, ); - END (scalbln); + END; } static const struct test_f_i_data signbit_test_data[] = { - START_DATA (signbit), /* TODO: missing qNaN tests. */ TEST_f_b (signbit, 0, 0, NO_INEXACT_EXCEPTION), TEST_f_b (signbit, minus_zero, 1, NO_INEXACT_EXCEPTION), @@ -13214,7 +13130,6 @@ static const struct test_f_i_data signbit_test_data[] = TEST_f_b (signbit, -1, 1, NO_INEXACT_EXCEPTION), /* signbit (x) == 0 for x >= 0. */ TEST_f_b (signbit, 1, 0, NO_INEXACT_EXCEPTION), - END_DATA (signbit) }; static void @@ -13222,13 +13137,12 @@ signbit_test (void) { START (signbit); RUN_TEST_LOOP_f_b_tg (signbit, signbit_test_data, ); - END (signbit); + END; } static const struct test_f_f_data sin_test_data[] = { - START_DATA (sin), TEST_f_f (sin, 0, 0), TEST_f_f (sin, minus_zero, minus_zero), TEST_f_f (sin, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM), @@ -13266,7 +13180,6 @@ static const struct test_f_f_data sin_test_data[] = TEST_f_f (sin, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L), TEST_f_f (sin, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L), TEST_f_f (sin, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L), - END_DATA (sin) }; static void @@ -13274,13 +13187,12 @@ sin_test (void) { START (sin); RUN_TEST_LOOP_f_f (sin, sin_test_data, ); - END (sin); + END; } static const struct test_f_f_data sin_tonearest_test_data[] = { - START_DATA (sin_tonearest), TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L), TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L), TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L), @@ -13291,7 +13203,6 @@ static const struct test_f_f_data sin_tonearest_test_data[] = TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L), TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L), TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L), - END_DATA (sin_tonearest) }; static void @@ -13299,13 +13210,12 @@ sin_test_tonearest (void) { START (sin_tonearest); RUN_TEST_LOOP_f_f (sin, sin_tonearest_test_data, FE_TONEAREST); - END (sin_tonearest); + END; } static const struct test_f_f_data sin_towardzero_test_data[] = { - START_DATA (sin_towardzero), TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L), TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L), TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L), @@ -13316,7 +13226,6 @@ static const struct test_f_f_data sin_towardzero_test_data[] = TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L), TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L), TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L), - END_DATA (sin_towardzero) }; static void @@ -13324,13 +13233,12 @@ sin_test_towardzero (void) { START (sin_towardzero); RUN_TEST_LOOP_f_f (sin, sin_towardzero_test_data, FE_TOWARDZERO); - END (sin_towardzero); + END; } static const struct test_f_f_data sin_downward_test_data[] = { - START_DATA (sin_downward), TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L), TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L), TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L), @@ -13341,7 +13249,6 @@ static const struct test_f_f_data sin_downward_test_data[] = TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L), TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L), TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L), - END_DATA (sin_downward) }; static void @@ -13349,13 +13256,12 @@ sin_test_downward (void) { START (sin_downward); RUN_TEST_LOOP_f_f (sin, sin_downward_test_data, FE_DOWNWARD); - END (sin_downward); + END; } static const struct test_f_f_data sin_upward_test_data[] = { - START_DATA (sin_upward), TEST_f_f (sin, 1, 0.8414709848078965066525023216302989996226L), TEST_f_f (sin, 2, 0.9092974268256816953960198659117448427023L), TEST_f_f (sin, 3, 0.1411200080598672221007448028081102798469L), @@ -13366,7 +13272,6 @@ static const struct test_f_f_data sin_upward_test_data[] = TEST_f_f (sin, 8, 0.9893582466233817778081235982452886721164L), TEST_f_f (sin, 9, 0.4121184852417565697562725663524351793439L), TEST_f_f (sin, 10, -0.5440211108893698134047476618513772816836L), - END_DATA (sin_upward) }; static void @@ -13374,20 +13279,18 @@ sin_test_upward (void) { START (sin_upward); RUN_TEST_LOOP_f_f (sin, sin_upward_test_data, FE_UPWARD); - END (sin_upward); + END; } -static const struct test_sincos_data sincos_test_data[] = +static const struct test_fFF_11_data sincos_test_data[] = { - START_DATA (sincos), - /* sincos is treated differently because it returns void. */ - TEST_extra (sincos, 0, 0, 1), + TEST_fFF_11 (sincos, 0, 0, 1), - TEST_extra (sincos, minus_zero, minus_zero, 1), - TEST_extra (sincos, plus_infty, qnan_value, qnan_value, INVALID_EXCEPTION), - TEST_extra (sincos, minus_infty, qnan_value, qnan_value, INVALID_EXCEPTION), - TEST_extra (sincos, qnan_value, qnan_value, qnan_value), + TEST_fFF_11 (sincos, minus_zero, minus_zero, 1), + TEST_fFF_11 (sincos, plus_infty, qnan_value, qnan_value, INVALID_EXCEPTION), + TEST_fFF_11 (sincos, minus_infty, qnan_value, qnan_value, INVALID_EXCEPTION), + TEST_fFF_11 (sincos, qnan_value, qnan_value, qnan_value), /* The value of M_PI_2l is never exactly PI/2, and therefore the answer is never exactly zero. The answer is equal to the error @@ -13395,52 +13298,51 @@ static const struct test_sincos_data sincos_test_data[] = to each type. */ #ifdef TEST_FLOAT /* 32-bit float. */ - TEST_extra (sincos, M_PI_2l, 1, -0x1.777a5cp-25L), + TEST_fFF_11 (sincos, M_PI_2l, 1, -0x1.777a5cp-25L), #endif #if defined TEST_DOUBLE || (defined TEST_LDOUBLE && LDBL_MANT_DIG == 53) /* 64-bit double or 64-bit long double. */ - TEST_extra (sincos, M_PI_2l, 1, 0x1.1a62633145c07p-54L), + TEST_fFF_11 (sincos, M_PI_2l, 1, 0x1.1a62633145c07p-54L), #endif #if defined TEST_LDOUBLE && LDBL_MANT_DIG == 64 /* 96-bit long double. */ - TEST_extra (sincos, M_PI_2l, 1, -0xe.ce675d1fc8f8cbbp-69L), + TEST_fFF_11 (sincos, M_PI_2l, 1, -0xe.ce675d1fc8f8cbbp-69L), #endif #if defined TEST_LDOUBLE && LDBL_MANT_DIG == 106 /* 128-bit IBM long double. */ - TEST_extra (sincos, M_PI_2l, 1, 0x1.c1cd129024e088a67cc74020bcp-107L), + TEST_fFF_11 (sincos, M_PI_2l, 1, 0x1.c1cd129024e088a67cc74020bcp-107L), #endif #if defined TEST_LDOUBLE && LDBL_MANT_DIG == 113 /* 128-bit long double. */ - TEST_extra (sincos, M_PI_2l, 1, 0x1.cd129024e088a67cc74020bbea64p-115L), + TEST_fFF_11 (sincos, M_PI_2l, 1, 0x1.cd129024e088a67cc74020bbea64p-115L), #endif - TEST_extra (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L), - TEST_extra (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5), - TEST_extra (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L), + TEST_fFF_11 (sincos, M_PI_6l, 0.5, 0.86602540378443864676372317075293616L), + TEST_fFF_11 (sincos, M_PI_6l*2.0, 0.86602540378443864676372317075293616L, 0.5), + TEST_fFF_11 (sincos, 0.75L, 0.681638760023334166733241952779893935L, 0.731688868873820886311838753000084544L), - TEST_extra (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L), - TEST_extra (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L), + TEST_fFF_11 (sincos, 0x1p65, -0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L), + TEST_fFF_11 (sincos, -0x1p65, 0.047183876212354673805106149805700013943218L, 0.99888622066058013610642172179340364209972L), #ifdef TEST_DOUBLE - TEST_extra (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473), + TEST_fFF_11 (sincos, 0.80190127184058835, 0.71867942238767868, 0.69534156199418473), #endif #ifndef TEST_FLOAT - TEST_extra (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L), - TEST_extra (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L), + TEST_fFF_11 (sincos, 1e22, -0.8522008497671888017727058937530293682618L, 0.5232147853951389454975944733847094921409L), + TEST_fFF_11 (sincos, 0x1p1023, 0.5631277798508840134529434079444683477104L, -0.826369834614147994500785680811743734805L), #endif #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 - TEST_extra (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L), + TEST_fFF_11 (sincos, 0x1p16383L, 0.3893629985894208126948115852610595405563L, 0.9210843909921906206874509522505756251609L), #endif - TEST_extra (sincos, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L, -9.25879022854837867303861764107414946730833e-01L), - TEST_extra (sincos, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L, 7.81914638714960072263910298466369236613162e-01L), - TEST_extra (sincos, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L, 9.98819362551949040703862043664101081064641e-01L), - TEST_extra (sincos, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L, 8.53021039830304158051791467692161107353094e-01L), - TEST_extra (sincos, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L, 8.68095904660550604334592502063501320395739e-01L), - TEST_extra (sincos, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L, -1.65568979490578758865468278195361551113358e-01L), - END_DATA (sincos) + TEST_fFF_11 (sincos, 0x1p+120, 3.77820109360752022655548470056922991960587e-01L, -9.25879022854837867303861764107414946730833e-01L), + TEST_fFF_11 (sincos, 0x1p+127, 6.23385512955870240370428801097126489001833e-01L, 7.81914638714960072263910298466369236613162e-01L), + TEST_fFF_11 (sincos, 0x1.fffff8p+127, 4.85786063130487339701113680434728152037092e-02L, 9.98819362551949040703862043664101081064641e-01L), + TEST_fFF_11 (sincos, 0x1.fffffep+127, -5.21876523333658540551505357019806722935726e-01L, 8.53021039830304158051791467692161107353094e-01L), + TEST_fFF_11 (sincos, 0x1p+50, 4.96396515208940840876821859865411368093356e-01L, 8.68095904660550604334592502063501320395739e-01L), + TEST_fFF_11 (sincos, 0x1p+28, -9.86198211836975655703110310527108292055548e-01L, -1.65568979490578758865468278195361551113358e-01L), }; static void @@ -13449,13 +13351,12 @@ sincos_test (void) FLOAT sin_res, cos_res; START (sincos); - RUN_TEST_LOOP_sincos (sincos_test_data, , sin_res, cos_res); - END (sincos); + RUN_TEST_LOOP_fFF_11 (sincos, sincos_test_data, , sin_res, cos_res); + END; } static const struct test_f_f_data sinh_test_data[] = { - START_DATA (sinh), TEST_f_f (sinh, 0, 0), TEST_f_f (sinh, minus_zero, minus_zero), @@ -13467,7 +13368,6 @@ static const struct test_f_f_data sinh_test_data[] = TEST_f_f (sinh, 0.75L, 0.822316731935829980703661634446913849L), TEST_f_f (sinh, 0x8p-32L, 1.86264514923095703232705808926175479e-9L), - END_DATA (sinh) }; static void @@ -13475,17 +13375,15 @@ sinh_test (void) { START (sinh); RUN_TEST_LOOP_f_f (sinh, sinh_test_data, ); - END (sinh); + END; } static const struct test_f_f_data sinh_tonearest_test_data[] = { - START_DATA (sinh_tonearest), TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L), TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L), TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L), - END_DATA (sinh_tonearest) }; static void @@ -13493,17 +13391,15 @@ sinh_test_tonearest (void) { START (sinh_tonearest); RUN_TEST_LOOP_f_f (sinh, sinh_tonearest_test_data, FE_TONEAREST); - END (sinh_tonearest); + END; } static const struct test_f_f_data sinh_towardzero_test_data[] = { - START_DATA (sinh_towardzero), TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L), TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L), TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L), - END_DATA (sinh_towardzero) }; static void @@ -13511,17 +13407,15 @@ sinh_test_towardzero (void) { START (sinh_towardzero); RUN_TEST_LOOP_f_f (sinh, sinh_towardzero_test_data, FE_TOWARDZERO); - END (sinh_towardzero); + END; } static const struct test_f_f_data sinh_downward_test_data[] = { - START_DATA (sinh_downward), TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L), TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L), TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L), - END_DATA (sinh_downward) }; static void @@ -13529,17 +13423,15 @@ sinh_test_downward (void) { START (sinh_downward); RUN_TEST_LOOP_f_f (sinh, sinh_downward_test_data, FE_DOWNWARD); - END (sinh_downward); + END; } static const struct test_f_f_data sinh_upward_test_data[] = { - START_DATA (sinh_upward), TEST_f_f (sinh, 22, 1792456423.065795780701106568345764104225L), TEST_f_f (sinh, 23, 4872401723.124451299966006944252978187305L), TEST_f_f (sinh, 24, 13244561064.92173614705070540368454568168L), - END_DATA (sinh_upward) }; static void @@ -13547,13 +13439,12 @@ sinh_test_upward (void) { START (sinh_upward); RUN_TEST_LOOP_f_f (sinh, sinh_upward_test_data, FE_UPWARD); - END (sinh_upward); + END; } static const struct test_f_f_data sqrt_test_data[] = { - START_DATA (sqrt), TEST_f_f (sqrt, 0, 0, NO_INEXACT_EXCEPTION), TEST_f_f (sqrt, qnan_value, qnan_value, NO_INEXACT_EXCEPTION), TEST_f_f (sqrt, plus_infty, plus_infty, NO_INEXACT_EXCEPTION), @@ -13572,7 +13463,6 @@ static const struct test_f_f_data sqrt_test_data[] = TEST_f_f (sqrt, 6642.25, 81.5, NO_INEXACT_EXCEPTION), TEST_f_f (sqrt, 15190.5625L, 123.25L, NO_INEXACT_EXCEPTION), TEST_f_f (sqrt, 0.75L, 0.866025403784438646763723170752936183L, INEXACT_EXCEPTION), - END_DATA (sqrt) }; static void @@ -13580,13 +13470,12 @@ sqrt_test (void) { START (sqrt); RUN_TEST_LOOP_f_f (sqrt, sqrt_test_data, ); - END (sqrt); + END; } static const struct test_f_f_data tan_test_data[] = { - START_DATA (tan), TEST_f_f (tan, 0, 0), TEST_f_f (tan, minus_zero, minus_zero), TEST_f_f (tan, plus_infty, qnan_value, INVALID_EXCEPTION|ERRNO_EDOM), @@ -13645,7 +13534,6 @@ static const struct test_f_f_data tan_test_data[] = #if defined TEST_LDOUBLE && LDBL_MAX_EXP >= 16384 TEST_f_f (tan, 0x1p16383L, 0.422722393732022337800504160054440141575L), #endif - END_DATA (tan) }; static void @@ -13653,13 +13541,12 @@ tan_test (void) { START (tan); RUN_TEST_LOOP_f_f (tan, tan_test_data, ); - END (tan); + END; } static const struct test_f_f_data tan_tonearest_test_data[] = { - START_DATA (tan_tonearest), TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L), TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L), TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L), @@ -13670,7 +13557,6 @@ static const struct test_f_f_data tan_tonearest_test_data[] = TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L), TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L), TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L), - END_DATA (tan_tonearest) }; static void @@ -13678,13 +13564,12 @@ tan_test_tonearest (void) { START (tan_tonearest); RUN_TEST_LOOP_f_f (tan, tan_tonearest_test_data, FE_TONEAREST); - END (tan_tonearest); + END; } static const struct test_f_f_data tan_towardzero_test_data[] = { - START_DATA (tan_towardzero), TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L), TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L), TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L), @@ -13695,7 +13580,6 @@ static const struct test_f_f_data tan_towardzero_test_data[] = TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L), TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L), TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L), - END_DATA (tan_towardzero) }; static void @@ -13703,13 +13587,12 @@ tan_test_towardzero (void) { START (tan_towardzero); RUN_TEST_LOOP_f_f (tan, tan_towardzero_test_data, FE_TOWARDZERO); - END (tan_towardzero); + END; } static const struct test_f_f_data tan_downward_test_data[] = { - START_DATA (tan_downward), TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L), TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L), TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L), @@ -13720,7 +13603,6 @@ static const struct test_f_f_data tan_downward_test_data[] = TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L), TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L), TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L), - END_DATA (tan_downward) }; static void @@ -13728,13 +13610,12 @@ tan_test_downward (void) { START (tan_downward); RUN_TEST_LOOP_f_f (tan, tan_downward_test_data, FE_DOWNWARD); - END (tan_downward); + END; } static const struct test_f_f_data tan_upward_test_data[] = { - START_DATA (tan_upward), TEST_f_f (tan, 1, 1.5574077246549022305069748074583601730873L), TEST_f_f (tan, 2, -2.1850398632615189916433061023136825434320L), TEST_f_f (tan, 3, -0.1425465430742778052956354105339134932261L), @@ -13745,7 +13626,6 @@ static const struct test_f_f_data tan_upward_test_data[] = TEST_f_f (tan, 8, -6.7997114552203786999252627596086333648814L), TEST_f_f (tan, 9, -0.4523156594418098405903708757987855343087L), TEST_f_f (tan, 10, 0.6483608274590866712591249330098086768169L), - END_DATA (tan_upward) }; static void @@ -13753,13 +13633,12 @@ tan_test_upward (void) { START (tan_upward); RUN_TEST_LOOP_f_f (tan, tan_upward_test_data, FE_UPWARD); - END (tan_upward); + END; } static const struct test_f_f_data tanh_test_data[] = { - START_DATA (tanh), TEST_f_f (tanh, 0, 0), TEST_f_f (tanh, minus_zero, minus_zero), @@ -13777,7 +13656,6 @@ static const struct test_f_f_data tanh_test_data[] = /* 2^-57 */ TEST_f_f (tanh, 0x1p-57L, 6.938893903907228377647697925567626953125e-18L), - END_DATA (tanh) }; static void @@ -13785,12 +13663,11 @@ tanh_test (void) { START (tanh); RUN_TEST_LOOP_f_f (tanh, tanh_test_data, ); - END (tanh); + END; } static const struct test_f_f_data tgamma_test_data[] = { - START_DATA (tgamma), TEST_f_f (tgamma, plus_infty, plus_infty), TEST_f_f (tgamma, max_value, plus_infty, OVERFLOW_EXCEPTION|ERRNO_ERANGE), TEST_f_f (tgamma, 0, plus_infty, DIVIDE_BY_ZERO_EXCEPTION|ERRNO_ERANGE), @@ -14309,7 +14186,6 @@ static const struct test_f_f_data tgamma_test_data[] = TEST_f_f (tgamma, 0x6.db8c603359a971081bc4a2e9dfd4p+8L, plus_infty, OVERFLOW_EXCEPTION|ERRNO_ERANGE), # endif #endif - END_DATA (tgamma) }; static void @@ -14317,13 +14193,12 @@ tgamma_test (void) { START (tgamma); RUN_TEST_LOOP_f_f (tgamma, tgamma_test_data, ); - END (tgamma); + END; } static const struct test_f_f_data trunc_test_data[] = { - START_DATA (trunc), TEST_f_f (trunc, plus_infty, plus_infty, NO_INEXACT_EXCEPTION), TEST_f_f (trunc, minus_infty, minus_infty, NO_INEXACT_EXCEPTION), TEST_f_f (trunc, qnan_value, qnan_value, NO_INEXACT_EXCEPTION), @@ -14425,7 +14300,6 @@ static const struct test_f_f_data trunc_test_data[] = TEST_f_f (trunc, 10141204801825835211973625643008.75L, 10141204801825835211973625643008.0L), TEST_f_f (trunc, 10141204801825835211973625643009.5L, 10141204801825835211973625643009.0L), #endif - END_DATA (trunc) }; static void @@ -14433,12 +14307,11 @@ trunc_test (void) { START (trunc); RUN_TEST_LOOP_f_f (trunc, trunc_test_data, ); - END (trunc); + END; } static const struct test_f_f_data y0_test_data[] = { - START_DATA (y0), /* y0 is the Bessel function of the second kind of order 0 */ TEST_f_f (y0, -1.0, minus_infty, INVALID_EXCEPTION|ERRNO_EDOM), TEST_f_f (y0, -max_value, minus_infty, INVALID_EXCEPTION|ERRNO_EDOM), @@ -14477,7 +14350,6 @@ static const struct test_f_f_data y0_test_data[] = TEST_f_f (y0, 0x1p-90L, -3.9788212322585974036636501709188067393195e+1L), TEST_f_f (y0, 0x1p-100L, -4.420092432563900590456563035154802121284e+1L), TEST_f_f (y0, 0x1p-110L, -4.861363632869203777249475899390797503250e+1L), - END_DATA (y0) }; static void @@ -14485,13 +14357,12 @@ y0_test (void) { START (y0); RUN_TEST_LOOP_f_f (y0, y0_test_data, ); - END (y0); + END; } static const struct test_f_f_data y1_test_data[] = { - START_DATA (y1), /* y1 is the Bessel function of the second kind of order 1 */ TEST_f_f (y1, -1.0, minus_infty, INVALID_EXCEPTION|ERRNO_EDOM), TEST_f_f (y1, -max_value, minus_infty, INVALID_EXCEPTION|ERRNO_EDOM), @@ -14530,7 +14401,6 @@ static const struct test_f_f_data y1_test_data[] = TEST_f_f (y1, 0x1p-90L, -7.8809710601457349582707849528059121757126e+26L), TEST_f_f (y1, 0x1p-100L, -8.0701143655892325972692837916732540679297e+29L), TEST_f_f (y1, 0x1p-110L, -8.2637971103633741796037466026734121655600e+32L), - END_DATA (y1) }; static void @@ -14538,13 +14408,12 @@ y1_test (void) { START (y1); RUN_TEST_LOOP_f_f (y1, y1_test_data, ); - END (y1); + END; } static const struct test_if_f_data yn_test_data[] = { - START_DATA (yn), /* yn is the Bessel function of the second kind of order n */ /* yn (0, x) == y0 (x) */ TEST_if_f (yn, 0, -1.0, minus_infty, INVALID_EXCEPTION|ERRNO_EDOM), @@ -14598,7 +14467,6 @@ static const struct test_if_f_data yn_test_data[] = /* Check whether yn returns correct value for LDBL_MIN, DBL_MIN, and FLT_MIN. See Bug 14173. */ TEST_if_f (yn, 10, min_value, minus_infty, OVERFLOW_EXCEPTION|ERRNO_ERANGE), - END_DATA (yn) }; static void @@ -14606,19 +14474,17 @@ yn_test (void) { START (yn); RUN_TEST_LOOP_if_f (yn, yn_test_data, ); - END (yn); + END; } static const struct test_f_f_data significand_test_data[] = { - START_DATA (significand), /* significand returns the mantissa of the exponential representation. */ /* TODO: missing +/-Inf as well as qNaN tests. */ TEST_f_f (significand, 4.0, 1.0, NO_INEXACT_EXCEPTION), TEST_f_f (significand, 6.0, 1.5, NO_INEXACT_EXCEPTION), TEST_f_f (significand, 8.0, 1.0, NO_INEXACT_EXCEPTION), - END_DATA (significand) }; static void @@ -14626,7 +14492,7 @@ significand_test (void) { START (significand); RUN_TEST_LOOP_f_f (significand, significand_test_data, ); - END (significand); + END; } @@ -14712,31 +14578,69 @@ parse_opt (int key, char *arg, struct argp_state *state) return 0; } -#if 0 -/* function to check our ulp calculation. */ +/* Verify that our ulp () implementation is behaving as expected + or abort. */ void check_ulp (void) { - int i; - - FLOAT u, diff, ulp; - /* This gives one ulp. */ - u = FUNC(nextafter) (10, 20); - check_equal (10.0, u, 1, &diff, &ulp); - printf ("One ulp: % .4" PRINTF_NEXPR "\n", ulp); - - /* This gives one more ulp. */ - u = FUNC(nextafter) (u, 20); - check_equal (10.0, u, 2, &diff, &ulp); - printf ("two ulp: % .4" PRINTF_NEXPR "\n", ulp); - - /* And now calculate 100 ulp. */ - for (i = 2; i < 100; i++) - u = FUNC(nextafter) (u, 20); - check_equal (10.0, u, 100, &diff, &ulp); - printf ("100 ulp: % .4" PRINTF_NEXPR "\n", ulp); + FLOAT ulps, ulpx, value; + int i; + /* Check ulp of zero is a subnormal value... */ + ulps = ulp (0x0.0p0); + if (fpclassify (ulps) != FP_SUBNORMAL) + { + fprintf (stderr, "ulp (0x0.0p0) is not FP_SUBNORMAL!\n"); + exit (EXIT_FAILURE); + } + /* Check that the ulp of one is a normal value... */ + ulps = ulp (1.0L); + if (fpclassify (ulps) != FP_NORMAL) + { + fprintf (stderr, "ulp (1.0L) is not FP_NORMAL\n"); + exit (EXIT_FAILURE); + } + + /* Compute the next subnormal value using nextafter to validate ulp. + We allow +/- 1 ulp around the represented value. */ + value = FUNC(nextafter) (0, 1); + ulps = ULPDIFF (value, 0); + ulpx = ulp (1.0L); + if (ulps < (1.0L - ulpx) || ulps > (1.0L + ulpx)) + { + fprintf (stderr, "Value outside of 1 +/- 1ulp.\n"); + exit (EXIT_FAILURE); + } + /* Compute the nearest representable number from 10 towards 20. + The result is 10 + 1ulp. We use this to check the ulp function. + We allow +/- 1 ulp around the represented value. */ + value = FUNC(nextafter) (10, 20); + ulps = ULPDIFF (value, 10); + ulpx = ulp (1.0L); + if (ulps < (1.0L - ulpx) || ulps > (1.0L + ulpx)) + { + fprintf (stderr, "Value outside of 1 +/- 1ulp.\n"); + exit (EXIT_FAILURE); + } + /* This gives one more ulp. */ + value = FUNC(nextafter) (value, 20); + ulps = ULPDIFF (value, 10); + ulpx = ulp (2.0L); + if (ulps < (2.0L - ulpx) || ulps > (2.0L + ulpx)) + { + fprintf (stderr, "Value outside of 2 +/- 1ulp.\n"); + exit (EXIT_FAILURE); + } + /* And now calculate 100 ulp. */ + for (i = 2; i < 100; i++) + value = FUNC(nextafter) (value, 20); + ulps = ULPDIFF (value, 10); + ulpx = ulp (100.0L); + if (ulps < (100.0L - ulpx) || ulps > (100.0L + ulpx)) + { + fprintf (stderr, "Value outside of 100 +/- 1ulp.\n"); + exit (EXIT_FAILURE); + } } -#endif int main (int argc, char **argv) @@ -14787,9 +14691,7 @@ main (int argc, char **argv) initialize (); printf (TEST_MSG); -#if 0 check_ulp (); -#endif /* Keep the tests a wee bit ordered (according to ISO C99). */ /* Classification macros: */ @@ -14866,6 +14768,7 @@ main (int argc, char **argv) logb_test (); logb_test_downward (); modf_test (); + pow10_test (); ilogb_test (); scalb_test (); scalbn_test (); @@ -14915,6 +14818,11 @@ main (int argc, char **argv) trunc_test (); /* Remainder functions: */ + drem_test (); + drem_test_tonearest (); + drem_test_towardzero (); + drem_test_downward (); + drem_test_upward (); fmod_test (); remainder_test (); remainder_test_tonearest (); diff --git a/libc/math/tst-CMPLX.c b/libc/math/tst-CMPLX.c index 5e9a501a5..fa0747b99 100644 --- a/libc/math/tst-CMPLX.c +++ b/libc/math/tst-CMPLX.c @@ -45,9 +45,7 @@ CMPLX (" #r ", " #i ") does not produce complex " #t ": %zu\n", s); \ C (CMPLXF, float); C (CMPLX, double); -# ifndef NO_LONG_DOUBLE C (CMPLXL, long double); -# endif #endif return result; diff --git a/libc/math/tst-CMPLX2.c b/libc/math/tst-CMPLX2.c index 4b62f8857..195ea7a84 100644 --- a/libc/math/tst-CMPLX2.c +++ b/libc/math/tst-CMPLX2.c @@ -120,14 +120,12 @@ check_double (void) double, comparec, CMPLX); } -# ifndef NO_LONG_DOUBLE static void check_long_double (void) { ALL_CHECKS (0.0l, -0.0l, __builtin_nanl (""), __builtin_infl (), long double, comparecl, CMPLXL); } -# endif #endif static int @@ -136,9 +134,7 @@ do_test (void) #ifdef CMPLX check_float (); check_double (); -# ifndef NO_LONG_DOUBLE check_long_double (); -# endif #endif return result; diff --git a/libc/nis/Makefile b/libc/nis/Makefile index 19eb27eee..3e973e059 100644 --- a/libc/nis/Makefile +++ b/libc/nis/Makefile @@ -85,12 +85,12 @@ $(objpfx)libnss_nis.so: $(objpfx)libnsl.so$(libnsl.so-version) \ $(common-objpfx)nss/libnss_files.so $(objpfx)libnss_nisplus.so: $(objpfx)libnsl.so$(libnsl.so-version) -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. libnsl-libc = $(common-objpfx)linkobj/libc.so +# Target-specific variable setting to link objects using deprecated +# RPC interfaces with the version of libc.so that makes them available +# for new links: $(services-y:%=$(objpfx)libnss_%.so) $(objpfx)libnsl.so: \ - $(libnsl-libc) $(common-objpfx)libc_nonshared.a + libc-for-link = $(libnsl-libc) ifeq ($(build-shared),yes) diff --git a/libc/nis/yp_xdr.c b/libc/nis/yp_xdr.c index 418850643..34566d19a 100644 --- a/libc/nis/yp_xdr.c +++ b/libc/nis/yp_xdr.c @@ -32,6 +32,14 @@ #include <rpcsvc/yp.h> #include <rpcsvc/ypclnt.h> +/* The NIS v2 protocol suggests 1024 bytes as a maximum length of all fields. + Current Linux systems don't use this limit. To remain compatible with + recent Linux systems we choose limits large enough to load large key and + data values, but small enough to not pose a DoS threat. */ + +#define XDRMAXNAME 1024 +#define XDRMAXRECORD (16 * 1024 * 1024) + bool_t xdr_ypstat (XDR *xdrs, ypstat *objp) { @@ -49,21 +57,21 @@ libnsl_hidden_def (xdr_ypxfrstat) bool_t xdr_domainname (XDR *xdrs, domainname *objp) { - return xdr_string (xdrs, objp, YPMAXDOMAIN); + return xdr_string (xdrs, objp, XDRMAXNAME); } libnsl_hidden_def (xdr_domainname) bool_t xdr_mapname (XDR *xdrs, mapname *objp) { - return xdr_string (xdrs, objp, YPMAXMAP); + return xdr_string (xdrs, objp, XDRMAXNAME); } libnsl_hidden_def (xdr_mapname) bool_t xdr_peername (XDR *xdrs, peername *objp) { - return xdr_string (xdrs, objp, YPMAXPEER); + return xdr_string (xdrs, objp, XDRMAXNAME); } libnsl_hidden_def (xdr_peername) @@ -71,7 +79,7 @@ bool_t xdr_keydat (XDR *xdrs, keydat *objp) { return xdr_bytes (xdrs, (char **) &objp->keydat_val, - (u_int *) &objp->keydat_len, YPMAXRECORD); + (u_int *) &objp->keydat_len, XDRMAXRECORD); } libnsl_hidden_def (xdr_keydat) @@ -79,7 +87,7 @@ bool_t xdr_valdat (XDR *xdrs, valdat *objp) { return xdr_bytes (xdrs, (char **) &objp->valdat_val, - (u_int *) &objp->valdat_len, YPMAXRECORD); + (u_int *) &objp->valdat_len, XDRMAXRECORD); } libnsl_hidden_def (xdr_valdat) diff --git a/libc/nptl/ChangeLog b/libc/nptl/ChangeLog index 6e5ca4cfa..7a9ce8e80 100644 --- a/libc/nptl/ChangeLog +++ b/libc/nptl/ChangeLog @@ -1,3 +1,8 @@ +2013-05-31 Joseph Myers <joseph@codesourcery.com> + + * Makefile ($(objpfx)libpthread.so): Remove dependencies on libc + and ld.so. + 2013-05-16 Ryan S. Arnold <rsa@linux.vnet.ibm.com> * pthread_create.c: Add missing #include <stdint.h> due to uint64_t or diff --git a/libc/nptl/Makefile b/libc/nptl/Makefile index 474a687f8..72ffa147b 100644 --- a/libc/nptl/Makefile +++ b/libc/nptl/Makefile @@ -526,14 +526,6 @@ $(objpfx)libpthread.so: $(addprefix $(objpfx),$(crti-objs) $(crtn-objs)) $(objpfx)libpthread.so: +preinit += $(addprefix $(objpfx),$(crti-objs)) $(objpfx)libpthread.so: +postinit += $(addprefix $(objpfx),$(crtn-objs)) -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -# Depend on ld.so too to get proper versions of ld.so symbols. -$(objpfx)libpthread.so: $(common-objpfx)libc.so \ - $(common-objpfx)libc_nonshared.a \ - $(elfobjdir)/ld.so - # Make sure we link with the thread library. ifeq ($(build-shared),yes) $(addprefix $(objpfx), \ diff --git a/libc/nptl_db/ChangeLog b/libc/nptl_db/ChangeLog index 34462ceb8..e0935e380 100644 --- a/libc/nptl_db/ChangeLog +++ b/libc/nptl_db/ChangeLog @@ -1,3 +1,8 @@ +2013-05-31 Joseph Myers <joseph@codesourcery.com> + + * Makefile ($(objpfx)libthread_db.so): Remove dependencies on + libc. + 2013-05-16 Ryan S. Arnold <rsa@linux.vnet.ibm.com> * db_info.c: Add missing #include <stdint.h> due to uint64_t or diff --git a/libc/nptl_db/Makefile b/libc/nptl_db/Makefile index 533fbaef8..77ea46e31 100644 --- a/libc/nptl_db/Makefile +++ b/libc/nptl_db/Makefile @@ -51,12 +51,6 @@ libthread_db.so-no-z-defs = yes include ../Rules -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -$(objpfx)libthread_db.so: $(common-objpfx)libc.so \ - $(common-objpfx)libc_nonshared.a - tests: $(objpfx)db-symbols.out $(objpfx)db-symbols.out: $(objpfx)db-symbols.v.i \ $(common-objpfx)nptl/libpthread.so diff --git a/libc/nss/Makefile b/libc/nss/Makefile index 83331b629..b4a504c9b 100644 --- a/libc/nss/Makefile +++ b/libc/nss/Makefile @@ -44,7 +44,7 @@ makedb-modules = xmalloc hash-string extra-objs += $(makedb-modules:=.o) tests = tst-nss-test1 -tests-$(OPTION_EGLIBC_INET) += test-netdb +tests-$(OPTION_EGLIBC_INET) += test-netdb test-digits-dots xtests-$(OPTION_EGLIBC_INET) += bug-erange include ../Makeconfig @@ -130,12 +130,11 @@ ifeq (yes,$(have-selinux)) LDLIBS-makedb := -lselinux endif -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. libnss-libc = $(common-objpfx)linkobj/libc.so -$(services:%=$(objpfx)libnss_%.so): $(libnss-libc) \ - $(common-objpfx)libc_nonshared.a +# Target-specific variable setting to link objects using deprecated +# RPC interfaces with the version of libc.so that makes them available +# for new links: +$(services:%=$(objpfx)libnss_%.so): libc-for-link = $(libnss-libc) $(objpfx)libnss_db.so: $(objpfx)libnss_files.so @@ -153,8 +152,7 @@ $(inst_vardbdir)/Makefile: db-Makefile $(+force) $(do-install) CFLAGS-nss_test1.c = -DNOT_IN_libc=1 -$(objpfx)/libnss_test1.so: $(objpfx)nss_test1.os $(common-objpfx)libc.so \ - $(common-objpfx)libc_nonshared.a +$(objpfx)/libnss_test1.so: $(objpfx)nss_test1.os $(link-libc-deps) $(build-module) ifdef libnss_test1.so-version $(objpfx)/libnss_test1.so$(libnss_test1.so-version): $(objpfx)/libnss_test1.so diff --git a/libc/nss/digits_dots.c b/libc/nss/digits_dots.c index 2b862956e..e007ef47a 100644 --- a/libc/nss/digits_dots.c +++ b/libc/nss/digits_dots.c @@ -46,7 +46,10 @@ __nss_hostname_digits_dots (const char *name, struct hostent *resbuf, { if (h_errnop) *h_errnop = NETDB_INTERNAL; - *result = NULL; + if (buffer_size == NULL) + *status = NSS_STATUS_TRYAGAIN; + else + *result = NULL; return -1; } @@ -83,14 +86,16 @@ __nss_hostname_digits_dots (const char *name, struct hostent *resbuf, } size_needed = (sizeof (*host_addr) - + sizeof (*h_addr_ptrs) + strlen (name) + 1); + + sizeof (*h_addr_ptrs) + + sizeof (*h_alias_ptr) + strlen (name) + 1); if (buffer_size == NULL) { if (buflen < size_needed) { + *status = NSS_STATUS_TRYAGAIN; if (h_errnop != NULL) - *h_errnop = TRY_AGAIN; + *h_errnop = NETDB_INTERNAL; __set_errno (ERANGE); goto done; } @@ -109,7 +114,7 @@ __nss_hostname_digits_dots (const char *name, struct hostent *resbuf, *buffer_size = 0; __set_errno (save); if (h_errnop != NULL) - *h_errnop = TRY_AGAIN; + *h_errnop = NETDB_INTERNAL; *result = NULL; goto done; } @@ -149,7 +154,9 @@ __nss_hostname_digits_dots (const char *name, struct hostent *resbuf, if (! ok) { *h_errnop = HOST_NOT_FOUND; - if (buffer_size) + if (buffer_size == NULL) + *status = NSS_STATUS_NOTFOUND; + else *result = NULL; goto done; } @@ -190,7 +197,7 @@ __nss_hostname_digits_dots (const char *name, struct hostent *resbuf, if (buffer_size == NULL) *status = NSS_STATUS_SUCCESS; else - *result = resbuf; + *result = resbuf; goto done; } @@ -201,15 +208,6 @@ __nss_hostname_digits_dots (const char *name, struct hostent *resbuf, if ((isxdigit (name[0]) && strchr (name, ':') != NULL) || name[0] == ':') { - const char *cp; - char *hostname; - typedef unsigned char host_addr_t[16]; - host_addr_t *host_addr; - typedef char *host_addr_list_t[2]; - host_addr_list_t *h_addr_ptrs; - size_t size_needed; - int addr_size; - switch (af) { default: @@ -225,7 +223,10 @@ __nss_hostname_digits_dots (const char *name, struct hostent *resbuf, /* This is not possible. We cannot represent an IPv6 address in an `struct in_addr' variable. */ *h_errnop = HOST_NOT_FOUND; - *result = NULL; + if (buffer_size == NULL) + *status = NSS_STATUS_NOTFOUND; + else + *result = NULL; goto done; case AF_INET6: @@ -233,42 +234,6 @@ __nss_hostname_digits_dots (const char *name, struct hostent *resbuf, break; } - size_needed = (sizeof (*host_addr) - + sizeof (*h_addr_ptrs) + strlen (name) + 1); - - if (buffer_size == NULL && buflen < size_needed) - { - if (h_errnop != NULL) - *h_errnop = TRY_AGAIN; - __set_errno (ERANGE); - goto done; - } - else if (buffer_size != NULL && *buffer_size < size_needed) - { - char *new_buf; - *buffer_size = size_needed; - new_buf = realloc (*buffer, *buffer_size); - - if (new_buf == NULL) - { - save = errno; - free (*buffer); - __set_errno (save); - *buffer = NULL; - *buffer_size = 0; - *result = NULL; - goto done; - } - *buffer = new_buf; - } - - memset (*buffer, '\0', size_needed); - - host_addr = (host_addr_t *) *buffer; - h_addr_ptrs = (host_addr_list_t *) - ((char *) host_addr + sizeof (*host_addr)); - hostname = (char *) h_addr_ptrs + sizeof (*h_addr_ptrs); - for (cp = name;; ++cp) { if (!*cp) @@ -281,7 +246,9 @@ __nss_hostname_digits_dots (const char *name, struct hostent *resbuf, if (inet_pton (AF_INET6, name, host_addr) <= 0) { *h_errnop = HOST_NOT_FOUND; - if (buffer_size) + if (buffer_size == NULL) + *status = NSS_STATUS_NOTFOUND; + else *result = NULL; goto done; } diff --git a/libc/nss/getXXbyYY_r.c b/libc/nss/getXXbyYY_r.c index 1067744d6..33e63d431 100644 --- a/libc/nss/getXXbyYY_r.c +++ b/libc/nss/getXXbyYY_r.c @@ -179,6 +179,9 @@ INTERNAL (REENTRANT_NAME) (ADD_PARAMS, LOOKUP_TYPE *resbuf, char *buffer, case -1: return errno; case 1: +#ifdef NEED_H_ERRNO + any_service = true; +#endif goto done; } #endif @@ -284,11 +287,11 @@ done: #endif *result = status == NSS_STATUS_SUCCESS ? resbuf : NULL; #ifdef NEED_H_ERRNO - if (status == NSS_STATUS_UNAVAIL) - /* Either we failed to lookup the functions or the functions themselves - had a system error. Set NETDB_INTERNAL here to let the caller know - that the errno may have the real reason for failure. */ - *h_errnop = NETDB_INTERNAL; + if (status == NSS_STATUS_UNAVAIL && !any_service && errno != ENOENT) + /* This happens when we weren't able to use a service for reasons other + than the module not being found. In such a case, we'd want to tell the + caller that errno has the real reason for failure. */ + *h_errnop = NETDB_INTERNAL; else if (status != NSS_STATUS_SUCCESS && !any_service) /* We were not able to use any service. */ *h_errnop = NO_RECOVERY; diff --git a/libc/nss/test-digits-dots.c b/libc/nss/test-digits-dots.c new file mode 100644 index 000000000..1efa3449a --- /dev/null +++ b/libc/nss/test-digits-dots.c @@ -0,0 +1,38 @@ +/* Copyright (C) 2013 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +/* Testcase for BZ #15014 */ + +#include <stdlib.h> +#include <netdb.h> +#include <errno.h> + +static int +do_test (void) +{ + char buf[32]; + struct hostent *result = NULL; + struct hostent ret; + int h_err = 0; + int err; + + err = gethostbyname_r ("1.2.3.4", &ret, buf, sizeof (buf), &result, &h_err); + return err == ERANGE && h_err == NETDB_INTERNAL ? EXIT_SUCCESS : EXIT_FAILURE; +} + +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" diff --git a/libc/ports/ChangeLog.aarch64 b/libc/ports/ChangeLog.aarch64 index a4fc2962d..46def45f6 100644 --- a/libc/ports/ChangeLog.aarch64 +++ b/libc/ports/ChangeLog.aarch64 @@ -1,3 +1,32 @@ +2013-05-29 Siddhesh Poyarekar <siddhesh@redhat.com> + + [BZ #15465] + * sysdeps/aarch64/dl-machine.h (elf_machine_rela): Use + RTLD_PROGNAME. + +2013-05-23 Venkataranmanan Kumar <venkataramanan.kumar@linaro.org> + + * sysdeps/aarch64/machine-gmon.h: Remove. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/aarch64/libm-test-ulps: Update test names. + +2013-05-21 Andreas Schwab <schwab@suse.de> + + [BZ #15493] + * sysdeps/aarch64/setjmp.S (__sigsetjmp): Don't clobber register + x1. + [NOT_IN_libc && IS_IN_rtld]: Don't call __sigjmp_save. + +2013-05-21 Marcus Shawcroft <marcus.shawcroft@linaro.org> + + * sysdeps/aarch64/libm-test-ulps: Regenerate. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/aarch64/libm-test-ulps: Update names of sincos tests. + 2013-05-16 Maciej W. Rozycki <macro@codesourcery.com> [BZ #15442] @@ -59,7 +88,7 @@ 2013-01-23 Marcus Shawcroft <marcus.shawcroft@linaro.org> - * sysdeps/aarch64/strncmp.S: New file. + * sysdeps/aarch64/strncmp.S: New file. 2013-01-23 Marcus Shawcroft <marcus.shawcroft@linaro.org> @@ -68,23 +97,23 @@ 2013-01-17 Marcus Shawcroft <marcus.shawcroft@linaro.org> - * sysdeps/aarch64/strlen.S: New file. + * sysdeps/aarch64/strlen.S: New file. 2013-01-17 Marcus Shawcroft <marcus.shawcroft@linaro.org> - * sysdeps/aarch64/strcmp.S: New file. + * sysdeps/aarch64/strcmp.S: New file. 2013-01-17 Marcus Shawcroft <marcus.shawcroft@linaro.org> - * sysdeps/aarch64/bzero.S: New file. + * sysdeps/aarch64/bzero.S: New file. 2013-01-17 Marcus Shawcroft <marcus.shawcroft@linaro.org> - * sysdeps/aarch64/memmove.S: New file. + * sysdeps/aarch64/memmove.S: New file. 2013-01-17 Marcus Shawcroft <marcus.shawcroft@linaro.org> - * sysdeps/aarch64/memcpy.S: New file. + * sysdeps/aarch64/memcpy.S: New file. 2013-01-17 Marcus Shawcroft <marcus.shawcroft@linaro.org> diff --git a/libc/ports/ChangeLog.alpha b/libc/ports/ChangeLog.alpha index 3c16ce007..2229bb606 100644 --- a/libc/ports/ChangeLog.alpha +++ b/libc/ports/ChangeLog.alpha @@ -1,3 +1,18 @@ +2013-05-22 Edjunior Barbosa Machado <emachado@linux.vnet.ibm.com> + + * sysdeps/unix/sysv/linux/alpha/bits/siginfo.h (siginfo_t): Add + si_trapno and si_addr_lsb to _sifields.sigfault. + (si_trapno, si_addr_lsb): Define new macros. + (BUS_MCEERR_AR, BUS_MCEERR_AO): Define new values. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/alpha/fpu/libm-test-ulps: Update test names. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/alpha/fpu/libm-test-ulps: Update names of sincos tests. + 2013-05-16 Maciej W. Rozycki <macro@codesourcery.com> [BZ #15442] diff --git a/libc/ports/ChangeLog.arm b/libc/ports/ChangeLog.arm index 81b2a56ee..7c025caad 100644 --- a/libc/ports/ChangeLog.arm +++ b/libc/ports/ChangeLog.arm @@ -1,3 +1,24 @@ +2013-05-31 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/arm/Makefile [$(subdir) = malloc] + ($(objpfx)libmemusage.so): Remove dependency on libc_nonshared. + [$(subdir) = math] ($(objpfx)libm.so): Remove dependency on ld.so. + +2013-05-29 Siddhesh Poyarekar <siddhesh@redhat.com> + + [BZ #15465] + * sysdeps/arm/dl-machine.h (elf_machine_rel): Use + RTLD_PROGNAME. + (elf_machine_rela): Likewise. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/arm/libm-test-ulps: Update test names. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/arm/libm-test-ulps: Update names of sincos tests. + 2013-05-16 Ryan S. Arnold <rsa@linux.vnet.ibm.com> * sysdeps/unix/sysv/linux/arm/bits/atomic.h: Add missing #include diff --git a/libc/ports/ChangeLog.hppa b/libc/ports/ChangeLog.hppa index a7bb51545..f31de9a89 100644 --- a/libc/ports/ChangeLog.hppa +++ b/libc/ports/ChangeLog.hppa @@ -1,3 +1,18 @@ +2013-05-29 Siddhesh Poyarekar <siddhesh@redhat.com> + + [BZ #15465] + * sysdeps/hppa/dl-machine.h (elf_machine_rela): Use + RTLD_PROGNAME. + (elf_machine_rela_relative): Likewise. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/hppa/fpu/libm-test-ulps: Update test names. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/hppa/fpu/libm-test-ulps: Update names of sincos tests. + 2013-05-15 Carlos O'Donell <carlos@redhat.com> * sysdeps/hppa/fpu/libm-test-ulps: Remove old values for ceil, floor, diff --git a/libc/ports/ChangeLog.ia64 b/libc/ports/ChangeLog.ia64 index 50b5604ec..46cddaff0 100644 --- a/libc/ports/ChangeLog.ia64 +++ b/libc/ports/ChangeLog.ia64 @@ -1,3 +1,18 @@ +2013-05-22 Edjunior Barbosa Machado <emachado@linux.vnet.ibm.com> + + * sysdeps/unix/sysv/linux/ia64/bits/siginfo.h (siginfo_t): Add + si_addr_lsb to _sifields.sigfault. + (si_addr_lsb): Define new macro. + (BUS_MCEERR_AR, BUS_MCEERR_AO): Define new values. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/ia64/fpu/libm-test-ulps: Update test names. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/ia64/fpu/libm-test-ulps: Update names of sincos tests. + 2013-03-12 Mike Frysinger <vapier@gentoo.org> * sysdeps/unix/sysv/linux/ia64/sysdep.h (INTERNAL_SYSCALL_DECL): Add diff --git a/libc/ports/ChangeLog.m68k b/libc/ports/ChangeLog.m68k index 16f3c75ef..b5a0c6d56 100644 --- a/libc/ports/ChangeLog.m68k +++ b/libc/ports/ChangeLog.m68k @@ -1,3 +1,20 @@ +2013-05-29 Siddhesh Poyarekar <siddhesh@redhat.com> + + [BZ #15465] + * sysdeps/m68k/dl-machine.h (elf_machine_rela): Use + RTLD_PROGNAME. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/m68k/coldfire/fpu/libm-test-ulps: Update test names. + * sysdeps/m68k/m680x0/fpu/libm-test-ulps: Likewise. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/m68k/coldfire/fpu/libm-test-ulps: Update names of sincos + tests. + * sysdeps/m68k/m680x0/fpu/libm-test-ulps: Likewise. + 2013-04-11 Andreas Schwab <schwab@suse.de> * sysdeps/m68k/m680x0/fpu/libm-test-ulps: Update diff --git a/libc/ports/ChangeLog.microblaze b/libc/ports/ChangeLog.microblaze index 4323270de..9890681cf 100644 --- a/libc/ports/ChangeLog.microblaze +++ b/libc/ports/ChangeLog.microblaze @@ -1,3 +1,35 @@ +2013-05-31 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/microblaze/Makefile ($(objpfx)libm.so): Remove + dependency on ld.so. + ($(objpfx)libcrypt.so): Likewise. + ($(objpfx)libresolv.so): Likewise. + ($(objpfx)libnss_dns.so): Likewise. + ($(objpfx)libnss_files.so): Likewise. + ($(objpfx)libnss_db.so): Likewise. + ($(objpfx)libnss_nis.so): Likewise. + ($(objpfx)libnss_nisplus.so): Likewise. + ($(objpfx)libnss_hesiod.so): Likewise. + ($(objpfx)libnss_compat.so): Likewise. + ($(objpfx)libanl.so): Likewise. + ($(objpfx)libnsl.so): Likewise. + ($(objpfx)libcidn.so): Likewise. + ($(objpfx)libutil.so): Likewise. + +2013-05-29 Siddhesh Poyarekar <siddhesh@redhat.com> + + [BZ #15465] + * sysdeps/microblaze/dl-machine.h (elf_machine_rela): Use + RTLD_PROGNAME. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/microblaze/libm-test-ulps: Update test names. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/microblaze/libm-test-ulps: Update names of sincos tests. + 2013-03-28 David Holsgrove <david.holsgrove@xilinx.com> * sysdeps/microblaze/Implies: New file. diff --git a/libc/ports/ChangeLog.mips b/libc/ports/ChangeLog.mips index 8640a121d..a50999258 100644 --- a/libc/ports/ChangeLog.mips +++ b/libc/ports/ChangeLog.mips @@ -1,3 +1,48 @@ +2013-05-29 Siddhesh Poyarekar <siddhesh@redhat.com> + + [BZ #15465] + * sysdeps/mips/dl-lookup.c (do_lookup_x): Use DSO_FILENAME. + (add_dependency): Likewise. + (_dl_lookup_symbol_x): Likewise. + (_dl_debug_bindings): Likewise. + * sysdeps/mips/dl-machine.h (elf_machine_reloc): Use + RTLD_PROGNAME. + +2013-05-22 Edjunior Barbosa Machado <emachado@linux.vnet.ibm.com> + + * sysdeps/unix/sysv/linux/mips/bits/siginfo.h (siginfo_t): Add + si_addr_lsb to _sifields.sifault. + (si_addr_lsb): Define new macro. + (BUS_MCEERR_AR, BUS_MCEERR_AO): Define new values. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/mips/mips32/libm-test-ulps: Update test names. + * sysdeps/mips/mips64/libm-test-ulps: Likewise. + +2013-05-21 Joseph Myers <joseph@codesourcery.com> + + [BZ #15506] + * sysdeps/unix/sysv/linux/mips/mips64/nptl/sysdep-cancel.h + [!__PIC__] (PSEUDO): Undefine and redefine. + (PSEUDO_END): Undefine and redefine unconditionally. + [!__PIC__] (STK_PAD): Define to 0. + [!__PIC__] (STKOFF_GP): Do not define. + [!__PIC__] (STKSPACE): Define to (STKOFF_SVMSK + SZREG). + (PSEUDO_JMP): Define depending on [__PIC__]. + (CENABLE): Use PSEUDO_JMP in all definitions. + (CDISABLE): Likewise. + * sysdeps/unix/sysv/linux/mips/mips64/n32/sysdep.h + (SYSCALL_ERROR_LABEL): Define unconditionally. + * sysdeps/unix/sysv/linux/mips/mips64/n64/sysdep.h + (SYSCALL_ERROR_LABEL): Define unconditionally. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/mips/mips32/libm-test-ulps: Update names of sincos + tests. + * sysdeps/mips/mips64/libm-test-ulps: Likewise. + 2013-05-16 Maciej W. Rozycki <macro@codesourcery.com> [BZ #15442] @@ -44,8 +89,8 @@ * sysdeps/unix/sysv/linux/mips/bits/msq.h (MSG_COPY): Define. 2013-02-27 Chung-Lin Tang <cltang@codesourcery.com> - Maciej W. Rozycki <macro@codesourcery.com> - Maxim Kuvyrkov <maxim@codesourcery.com> + Maciej W. Rozycki <macro@codesourcery.com> + Maxim Kuvyrkov <maxim@codesourcery.com> * sysdeps/mips/abort-instr.h (ABORT_INSTRUCTION) [__mips16]: New macro. @@ -506,7 +551,7 @@ 2012-11-06 Maxim Kuvyrkov <maxim@codesourcery.com> - * sysdeps/mips/memmove.c: New file. Use memcpy for forward memmove. + * sysdeps/mips/memmove.c: New file. Use memcpy for forward memmove. 2012-11-05 Joseph Myers <joseph@codesourcery.com> @@ -658,14 +703,14 @@ 2012-08-13 Maxim Kuvyrkov <maxim@codesourcery.com> - [__GNUC_PREREQ (4, 8)] - (atomic_exchange_and_add): Split into ... - (atomic_exchange_and_add_acq, atomic_exchange_and_add_rel): ... these. - New atomic macros. - [!__GNUC_PREREQ (4, 8)] - (atomic_exchange_and_add): Split into ... - (atomic_exchange_and_add_acq, atomic_exchange_and_add_rel): ... these. - New atomic macros. + [__GNUC_PREREQ (4, 8)] + (atomic_exchange_and_add): Split into ... + (atomic_exchange_and_add_acq, atomic_exchange_and_add_rel): ... these. + New atomic macros. + [!__GNUC_PREREQ (4, 8)] + (atomic_exchange_and_add): Split into ... + (atomic_exchange_and_add_acq, atomic_exchange_and_add_rel): ... these. + New atomic macros. 2012-08-09 Joseph Myers <joseph@codesourcery.com> @@ -727,21 +772,21 @@ Likewise. 2012-07-11 Tom de Vries <vries@codesourcery.com> - Maxim Kuvyrkov <maxim@codesourcery.com> - - * sysdeps/mips/bits/atomic.h [__GNUC_PREREQ (4, 8)] - (__arch_compare_and_exchange_bool_32_int) - (__arch_compare_and_exchange_val_32_int) - (__arch_compare_and_exchange_bool_64_int) - (__arch_compare_and_exchange_val_64_int) - Define in terms of __atomic_compare_exchange_n. - [__GNUC_PREREQ (4, 8)] - (__arch_exchange_32_int, __arch_exchange_64_int): - Define in terms of __atomic_exchange_n. - [__GNUC_PREREQ (4, 8)] - (__arch_exchange_and_add_32_int, __arch_exchange_and_add_64_int): - Define in terms of __atomic_fetch_add. - [!__GNUC_PREREQ (4, 8)]: Update formatting. + Maxim Kuvyrkov <maxim@codesourcery.com> + + * sysdeps/mips/bits/atomic.h [__GNUC_PREREQ (4, 8)] + (__arch_compare_and_exchange_bool_32_int) + (__arch_compare_and_exchange_val_32_int) + (__arch_compare_and_exchange_bool_64_int) + (__arch_compare_and_exchange_val_64_int) + Define in terms of __atomic_compare_exchange_n. + [__GNUC_PREREQ (4, 8)] + (__arch_exchange_32_int, __arch_exchange_64_int): + Define in terms of __atomic_exchange_n. + [__GNUC_PREREQ (4, 8)] + (__arch_exchange_and_add_32_int, __arch_exchange_and_add_64_int): + Define in terms of __atomic_fetch_add. + [!__GNUC_PREREQ (4, 8)]: Update formatting. 2012-07-06 Petar Jovanovic <petar.jovanovic@rt-rk.com> diff --git a/libc/ports/ChangeLog.powerpc b/libc/ports/ChangeLog.powerpc index 073df4f0b..93f249e29 100644 --- a/libc/ports/ChangeLog.powerpc +++ b/libc/ports/ChangeLog.powerpc @@ -1,3 +1,12 @@ +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/powerpc/nofpu/libm-test-ulps: Update test names. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/powerpc/nofpu/libm-test-ulps: Update names of sincos + tests. + 2013-05-16 Maciej W. Rozycki <macro@codesourcery.com> [BZ #15442] diff --git a/libc/ports/ChangeLog.tile b/libc/ports/ChangeLog.tile index 5cfa0b15f..dcfe00e52 100644 --- a/libc/ports/ChangeLog.tile +++ b/libc/ports/ChangeLog.tile @@ -1,3 +1,33 @@ +2013-05-29 Siddhesh Poyarekar <siddhesh@redhat.com> + + [BZ #15465] + * sysdeps/tile/dl-machine.h (elf_machine_rela): Use + RTLD_PROGNAME. + +2013-05-23 Chris Metcalf <cmetcalf@tilera.com> + + * sysdeps/tile/tilegx/Makefile ($(cflags-mcmodel-large)): + Test for assembler and linker support for "-mcmodel=large -fpic" + in addition to compiler support; provide -DNO_PLT_PCREL if not. + * sysdeps/tile/start.S [NO_PLT_PCREL]: Guard for no PC-relative + PLT operators in assembly. + * sysdeps/tile/crti.S [NO_PLT_PCREL]: Likewise. + +2013-05-22 Edjunior Barbosa Machado <emachado@linux.vnet.ibm.com> + + * sysdeps/unix/sysv/linux/tile/bits/siginfo.h (siginfo_t): Fix comment + formatting. Add si_addr_lsb to _sifields.sigfault. + (si_addr_lsb): Define new macro. + (BUS_MCEERR_AR, BUS_MCEERR_AO): Define new values. + +2013-05-22 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/tile/libm-test-ulps: Update test names. + +2013-05-19 Joseph Myers <joseph@codesourcery.com> + + * sysdeps/tile/libm-test-ulps: Update names of sincos tests. + 2013-05-16 Ryan S. Arnold <rsa@linux.vnet.ibm.com> * sysdeps/tile/tilegx/memusage.h: Add missing #include <stdint.h> due diff --git a/libc/ports/sysdeps/aarch64/dl-machine.h b/libc/ports/sysdeps/aarch64/dl-machine.h index 702a7c028..c91b0c42e 100644 --- a/libc/ports/sysdeps/aarch64/dl-machine.h +++ b/libc/ports/sysdeps/aarch64/dl-machine.h @@ -257,8 +257,7 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc, strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/ports/sysdeps/aarch64/libm-test-ulps b/libc/ports/sysdeps/aarch64/libm-test-ulps index aebc46f46..dc7dc341b 100644 --- a/libc/ports/sysdeps/aarch64/libm-test-ulps +++ b/libc/ports/sysdeps/aarch64/libm-test-ulps @@ -1,19 +1,19 @@ # Begin of automatic generation # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 @@ -22,19 +22,19 @@ ildouble: 1 ldouble: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 @@ -43,314 +43,1494 @@ ildouble: 1 ldouble: 1 # acos_upward -Test "acos_upward (-0) == pi/2": +Test "acos_upward (-0)": ildouble: 1 ldouble: 1 -Test "acos_upward (-1) == pi": +Test "acos_upward (-1)": ildouble: 1 ldouble: 1 -Test "acos_upward (0) == pi/2": +Test "acos_upward (0)": ildouble: 1 ldouble: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (-1.0) == -pi/2": +Test "asin_downward (-1.0)": ildouble: 1 ldouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 # asin_upward -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 -Test "asin_upward (1.0) == pi/2": +Test "asin_upward (1.0)": ildouble: 1 ldouble: 1 # atan2 -Test "atan2 (-0.00756827042671106339, -.001792735857538728036) == -1.80338464113663849327153994379639112": +Test "atan2 (-0.00756827042671106339, -.001792735857538728036)": ildouble: 1 ldouble: 1 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + +0 i) == 2.094395102393195492308428922186335256131 - 0 i": +Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0 i) == 2.094395102393195492308428922186335256131 + +0 i": +Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0.0 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.0 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.0 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.0 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.0 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.0 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.25 + 1.0 i)": double: 1 +float: 1 idouble: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0.25 + 1.0 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0.25 - 1.0 i)": double: 1 +float: 1 idouble: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0.25 - 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0.5 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 + 0x1.fp-129 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (-0.5 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.5 + 0x1p-105 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 + 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.5 + 0x1p-112 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 + 0x1p-52 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.5 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0.5 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 - 0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 - 0x1.fp-129 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (-0.5 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.5 - 0x1p-105 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 - 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 - 0x1p-52 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0.5 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p500 + 1.0 i) == 3.141592653589793238462643383279502884197 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p500 - 1.0 i) == 3.141592653589793238462643383279502884197 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p5000 + 1.0 i) == 3.141592653589793238462643383279502884197 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p5000 - 1.0 i) == 3.141592653589793238462643383279502884197 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 + 0x1p50 i) == 1.570796326794897507409741391764983781004 - 3.535050620855721078027883819436759661753e1 i": +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 - 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1p500 i) == 1.570796326794896619231321691639751442099 - 3.472667374605326000180332928505464606058e2 i": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1p5000 i) == 1.570796326794896619231321691639751442099 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (-0x1.000002p0 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (-0x1.fp-100 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 - 0x1p50 i) == 1.570796326794897507409741391764983781004 + 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-0x1.fp-100 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1p500 i) == 1.570796326794896619231321691639751442099 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-10000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1p5000 i) == 1.570796326794896619231321691639751442099 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-1025 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-1025 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-1025 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1.fp-129 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1.fp-129 + 0x0.ffffffp0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1.fp-129 + 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1.fp-129 + 0x1.fp-129 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1.fp-129 + 0x1p-23 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1.fp-129 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-2 - 3 i) == 2.1414491111159960199416055713254211 + 1.9833870299165354323470769028940395 i": +Test "Real part of: cacos (-0x1.fp-129 + 1.5 i)": float: 1 ifloat: 1 +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (-0x1.fp-129 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1.fp-129 - 0x0.ffffffp0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1.fp-129 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1.fp-129 - 0x1.fp-129 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1.fp-129 - 0x1p-23 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1.fp-129 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i)": double: 1 +float: 1 idouble: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (-0x1.fp-129 - 1.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-16385 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-16385 + 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-16385 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1.fp-16385 - 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1.fp-30 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i)": double: 1 +float: 1 idouble: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1.fp-30 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i)": double: 1 +float: 1 idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-105 + 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-105 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-105 + 0x1p-105 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-105 - 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-105 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-105 - 0x1p-105 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-112 + 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-112 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-112 + 0x1p-112 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-112 - 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-112 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-112 - 0x1p-112 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442097 - 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-23 + 0.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-23 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 +Test "Real part of: cacos (-0x1p-23 + 0x1.fp-129 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442097 + 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1p-23 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-23 - 0.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-23 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 +Test "Real part of: cacos (-0x1p-23 - 0x1.fp-129 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-23 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-52 + 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-52 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-52 + 0x1p-52 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-52 - 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-52 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-52 - 0x1p-52 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-63 + 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-63 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1p-63 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-0x1p-63 + 0x1p-63 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-63 - 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (-0x1p-63 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1p-63 - 0x1p-63 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1p500 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1p5000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-0x1p5000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-1.0 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-1.0 + 0x1p50 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-1.0 + 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-1.0 + 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-1.0 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 - 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-1.0 - 0x1p50 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (-1.0 - 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-1.0 - 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 +float: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 - 8.973081118419833726837456344608533993585e1 i": +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (-2 - 3 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.0 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.0 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.0 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.0 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.0 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.0 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.25 + 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.25 - 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp16383 + 0x1.fp16383 i) == 7.853981633974483096156608458198757210493e-1 - 1.135753137836666928715489992987020363057e4 i": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p500 + 1.0 i) == 3.054936363499604682051979393213617699789e-151 - 3.472667374605326000180332928505464606058e2 i": +Test "Real part of: cacos (0.5 + 0x1.fp-1025 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0.5 + 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0.5 + 0x1p-105 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0.5 + 0x1p-105 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p500 - 1.0 i) == 3.054936363499604682051979393213617699789e-151 + 3.472667374605326000180332928505464606058e2 i": +Test "Real part of: cacos (0.5 + 0x1p-112 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0.5 + 0x1p-112 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p5000 + 1.0 i) == 7.079811261048172892385615158694057552948e-1506 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-23 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p5000 - 1.0 i) == 7.079811261048172892385615158694057552948e-1506 + 3.466429049980286492395577839412341016946e3 i": +Test "Real part of: cacos (0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 + 0x1p500 i) == 1.570796326794896619231321691639751442099 - 3.472667374605326000180332928505464606058e2 i": +Test "Real part of: cacos (0.5 + 0x1p-63 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 + 0x1p5000 i) == 1.570796326794896619231321691639751442099 - 3.466429049980286492395577839412341016946e3 i": +Test "Real part of: cacos (0.5 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (0.5 + 1.0 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 - 0x1p500 i) == 1.570796326794896619231321691639751442099 + 3.472667374605326000180332928505464606058e2 i": +Test "Real part of: cacos (0.5 - 0 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 - 0x1p5000 i) == 1.570796326794896619231321691639751442099 + 3.466429049980286492395577839412341016946e3 i": +Test "Real part of: cacos (0.5 - 0x1.fp-1025 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0.5 - 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0.5 - 0x1p-105 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0.5 - 0x1p-105 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0.5 - 0x1p-112 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0.5 - 0x1p-112 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.5 - 0x1p-23 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Real part of: cacos (0.5 - 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0.5 - 0x1p-63 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0.5 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0.5 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (0.5 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0.75 + 1.25 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0.0 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0.0 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": +float: 2 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": +float: 2 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 + 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 - 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i)": +ildouble: 2 +ldouble: 2 +Test "Real part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i)": +ildouble: 2 +ldouble: 2 +Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i)": +float: 2 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.000002p0 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i)": +float: 2 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.000002p0 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0x1.fp-100 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1.fp-100 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-10000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-10000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1025 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1025 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1025 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1025 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 + 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-16385 - 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (0x1.fp16383 + 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-105 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-105 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-112 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-112 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-23 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0x1p-23 + 0x1.000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-23 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (0x1p-23 - 0x1.000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1p-52 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-52 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1p-52 + 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1p-52 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-52 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1p-52 - 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1p-63 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-63 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (0x1p-63 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-63 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (0x1p-63 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-63 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (0x1p-63 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p-63 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p500 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p500 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p5000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (0x1p5000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (1.0 + 0.25 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (1.0 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (1.0 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (1.0 + 0x1.fp-10 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (1.0 + 0x1.fp-100 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (1.0 + 0x1.fp-30 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (1.0 + 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (1.0 + 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (1.0 + 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (1.0 - 0.25 i)": +double: 1 +idouble: 1 +Test "Real part of: cacos (1.0 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacos (1.0 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacos (1.0 - 0x1.fp-10 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (1.0 - 0x1.fp-100 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacos (1.0 - 0x1.fp-30 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacos (1.0 - 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (1.0 - 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (1.0 - 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 @@ -359,292 +1539,2659 @@ ildouble: 1 ldouble: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.0 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.0 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.0 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.0 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.0 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.0 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.25 + 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.25 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "Real part of: cacosh (-0.25 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.25 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 +Test "Imaginary part of: cacosh (-0.5 + +0 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 +Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 + 0x1p-112 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 + 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 + 0x1p-23 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 + 0x1p-52 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-129 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 - 0x1p-105 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 - 0x1p-112 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 - 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 - 0x1p-23 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 - 0x1p-52 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0.5 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 + 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 - 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.000002p0 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1.fp-100 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i)": +double: 1 float: 1 +idouble: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1.fp-100 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-10000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-10000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1025 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1025 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1025 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1025 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x0.ffffffp0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.fp-129 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1p-23 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x0.ffffffp0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.fp-129 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1p-23 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1.fp-16385 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 + 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-16385 - 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1.fp-30 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1.fp-30 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-105 + 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-105 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-105 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-105 + 0x1p-105 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-105 - 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-105 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-105 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-105 - 0x1p-105 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-112 + 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-112 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-112 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-112 + 0x1p-112 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-112 - 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-112 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-112 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-112 - 0x1p-112 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-23 + 0.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1p-23 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: cacosh (-0x1p-23 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (-0x1p-23 + 0x1.fp-129 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-23 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-23 - 0.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1p-23 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: cacosh (-0x1p-23 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (-0x1p-23 - 0x1.fp-129 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-23 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-52 + 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-52 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-52 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-52 + 0x1p-52 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-52 - 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-52 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-52 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-52 - 0x1p-52 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-63 + 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-63 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-63 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1p-63 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-63 + 0x1p-63 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-63 - 0.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-63 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-0x1p-63 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1p-63 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-0x1p-63 - 0x1p-63 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-0x1p500 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1p500 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1p5000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-0x1p5000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-1.0 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-1.0 + 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-1.0 + 0x1p50 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-1.0 + 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-1.0 + 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-1.0 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-1.0 - 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (-1.0 - 0x1p50 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-1.0 - 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-1.0 - 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (-1.5 + +0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (-1.5 - 0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (-2 - 3 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.0 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.0 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.0 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.0 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.0 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.0 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.25 + 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.25 - 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 + +0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0.5 + 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0.5 + 0x1p-105 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0.5 + 0x1p-112 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0.5 + 0x1p-23 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.5 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0.5 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (0.5 - 0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0.5 - 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0.5 - 0x1p-105 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0.5 - 0x1p-112 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0.5 - 0x1p-23 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0.5 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0.5 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0.5 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0.0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0.0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": +float: 2 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": +float: 2 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 + 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 - 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i)": +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i)": +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.000002p0 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i)": +float: 2 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.000002p0 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i)": +float: 2 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-10 + 1.0 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0x1.fp-10 - 1.0 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0x1.fp-100 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1.fp-100 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-100 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1.fp-100 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-10000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-10000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1025 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1025 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1025 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1025 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-129 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-129 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-129 + 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-129 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-129 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-129 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 + 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-16385 - 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-30 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp-30 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (0x1.fp16383 + 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-105 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-105 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-112 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-112 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-23 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (0x1p-23 + 0x1.000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-23 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: cacosh (0x1p-23 - 0x1.000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-52 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1p-52 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1p-52 + 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-52 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1p-52 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (0x1p-52 - 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-63 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (0x1p-63 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-63 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-63 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (0x1p-63 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p-63 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p500 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p500 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p5000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (0x1p5000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (1.0 + 0.25 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (1.0 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (1.0 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (1.0 + 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-100 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (1.0 + 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-30 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (1.0 + 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (1.0 + 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (1.0 - 0.25 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (1.0 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: cacosh (1.0 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (1.0 - 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-100 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (1.0 - 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-30 i)": +double: 1 +idouble: 1 +Test "Real part of: cacosh (1.0 - 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (1.0 - 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: cacosh (1.5 + +0 i)": +float: 1 +ifloat: 1 +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.0 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.0 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.0 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.0 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.0 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.0 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.25 + 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.25 - 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (-0.5 + 0x1p-105 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0.5 + 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.5 + 0x1p-112 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0.5 + 0x1p-23 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.5 + 0x1p-23 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0.5 + 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (-0.5 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0.5 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.5 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (-0.5 - 0x1p-105 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0.5 - 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.5 - 0x1p-112 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0.5 - 0x1p-23 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.5 - 0x1p-23 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0.5 - 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (-0.5 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0.5 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0.5 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.fffffffffffff8p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Real part of: casin (-0x0.fffffffffffff8p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.ffffffffffffffffp0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.ffffffffffffffffp0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x0.ffffffp0 + 0x1p-23 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Real part of: casin (-0x0.ffffffp0 - 0x1p-23 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 + 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 - 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.000002p0 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.000002p0 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x1.fp-10 + 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 +Test "Real part of: casin (-0x1.fp-10 - 1.0 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i) == -2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 +Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i) == -2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i)": double: 1 +float: 1 idouble: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i) == -1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i) == -1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 + 1.5 i) == -4.516698239814521372306784062043266700598e-4933 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-10000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-10000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-1025 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 - 1.5 i) == -4.516698239814521372306784062043266700598e-4933 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p500 + 1.0 i) == -1.570796326794896619231321691639751442099 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p500 - 1.0 i) == -1.570796326794896619231321691639751442099 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p5000 + 1.0 i) == -1.570796326794896619231321691639751442099 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p5000 - 1.0 i) == -1.570796326794896619231321691639751442099 - 3.466429049980286492395577839412341016946e3 i": +Test "Real part of: casin (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1p500 i) == -3.054936363499604682051979393213617699789e-151 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1p5000 i) == -7.079811261048172892385615158694057552948e-1506 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1p500 i) == -3.054936363499604682051979393213617699789e-151 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1p5000 i) == -7.079811261048172892385615158694057552948e-1506 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i) == 2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i) == 2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-16385 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 + 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1.fp-16385 - 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x1.fp-30 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i) == 1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i)": double: 1 +float: 1 idouble: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i) == 1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Real part of: casin (-0x1.fp-30 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 + 1.5 i) == 4.516698239814521372306784062043266700598e-4933 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 - 1.5 i) == 4.516698239814521372306784062043266700598e-4933 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1p-105 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 + 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: casin (-0x1p-105 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1p-112 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (-0x1p-112 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: casin (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x1p-23 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casin (-0x1p-23 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 + 8.973081118419833726837456344608533993585e1 i": +Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i)": double: 1 +float: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp16383 + 0x1.fp16383 i) == 7.853981633974483096156608458198757210493e-1 + 1.135753137836666928715489992987020363057e4 i": +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p500 + 1.0 i) == 1.570796326794896619231321691639751442099 + 3.472667374605326000180332928505464606058e2 i": +Test "Real part of: casin (-0x1p-23 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casin (-0x1p-23 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i)": +double: 1 +idouble: 1 +Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x1p-52 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1p-52 + 0.5 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p500 - 1.0 i) == 1.570796326794896619231321691639751442099 - 3.472667374605326000180332928505464606058e2 i": +Test "Real part of: casin (-0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p5000 + 1.0 i) == 1.570796326794896619231321691639751442099 + 3.466429049980286492395577839412341016946e3 i": +Test "Real part of: casin (-0x1p-52 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p5000 - 1.0 i) == 1.570796326794896619231321691639751442099 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-0x1p-52 - 0.5 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1p500 i) == 3.054936363499604682051979393213617699789e-151 + 3.472667374605326000180332928505464606058e2 i": +Test "Real part of: casin (-0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1p5000 i) == 7.079811261048172892385615158694057552948e-1506 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-0x1p-63 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1p500 i) == 3.054936363499604682051979393213617699789e-151 - 3.472667374605326000180332928505464606058e2 i": +Test "Real part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1p5000 i) == 7.079811261048172892385615158694057552948e-1506 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-0x1p-63 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1p500 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1p500 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1p5000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-0x1p5000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-1.0 + 0.25 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-1.0 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (-1.0 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-1.0 + 0x1.fp-129 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-1.0 + 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-1.0 + 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-1.0 + 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-1.0 - 0.25 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-1.0 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (-1.0 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (-1.0 - 0x1.fp-129 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-1.0 - 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-1.0 - 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-1.0 - 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (-1.5 + +0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.0 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.0 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.0 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.0 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.0 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.0 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.25 + 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.25 - 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (0.5 + 0x1p-105 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0.5 + 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.5 + 0x1p-112 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0.5 + 0x1p-23 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.5 + 0x1p-23 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0.5 + 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (0.5 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0.5 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.5 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (0.5 - 0x1p-105 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0.5 - 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.5 - 0x1p-112 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0.5 - 0x1p-23 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.5 - 0x1p-23 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0.5 - 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (0.5 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0.5 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0.5 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0.75 + 1.25 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "Imaginary part of: casin (0.75 + 1.25 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.fffffffffffff8p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Real part of: casin (0x0.fffffffffffff8p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i)": +double: 1 +idouble: 1 +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-112 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.ffffffffffffffffp0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.ffffffffffffffffp0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x0.ffffffp0 + 0x1p-23 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Real part of: casin (0x0.ffffffp0 - 0x1p-23 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 + 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 - 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.000002p0 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.000002p0 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1.fp-10 + 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i)": +double: 1 +idouble: 1 +Test "Real part of: casin (0x1.fp-10 - 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-10000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-10000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1025 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1025 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1025 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1025 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 + 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-16385 - 1.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1.fp-30 + 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1.fp-30 - 1.0 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casin (0x1.fp16383 + 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-105 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-105 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-112 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (0x1p-112 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Real part of: casin (0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1p-23 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casin (0x1p-23 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i)": +double: 1 +idouble: 1 +Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1p-23 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casin (0x1p-23 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i)": +double: 1 +idouble: 1 +Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1p-52 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-52 + 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1p-52 + 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1p-52 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-52 - 0.5 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1p-52 - 0x1.0000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-63 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1p-63 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-63 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-63 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (0x1p-63 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p-63 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p500 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p500 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p5000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (0x1p5000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (1.0 + 0.25 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (1.0 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (1.0 + 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (1.0 + 0x1.fp-129 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (1.0 + 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (1.0 + 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (1.0 + 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (1.0 - 0.25 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (1.0 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (1.0 - 0.5 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casin (1.0 - 0x1.fp-129 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (1.0 - 0x1.fp-30 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (1.0 - 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (1.0 - 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 @@ -653,1065 +4200,2655 @@ ildouble: 1 ldouble: 1 # casinh -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Imaginary part of: casinh (-0.0 + 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0.0 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.0 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0.0 - 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0.0 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.0 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0.25 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0.25 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.5 + 0x1.fp-129 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.5 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.5 + 0x1p-105 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (-0.5 + 0x1p-112 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (-0.5 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Real part of: casinh (-0.5 + 0x1p-52 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0.5 + 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.5 + 0x1p-63 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (-0.5 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casinh (-0.5 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p500 + 1.0 i) == -3.472667374605326000180332928505464606058e2 + 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (-0.5 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.5 - 0x1.fp-129 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.5 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.5 - 0x1p-105 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (-0.5 - 0x1p-112 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (-0.5 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Real part of: casinh (-0.5 - 0x1p-52 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0.5 - 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0.5 - 0x1p-63 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (-0.5 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casinh (-0.5 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casinh (-0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 + 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.0000000000000000000000000001p0 + 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 - 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.0000000000000000000000000001p0 - 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000002p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000002p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000002p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000002p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000001p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000001p0 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.0000000000001p0 + 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000001p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.0000000000001p0 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.0000000000001p0 - 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.fp-10 + 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.fp-10 - 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.fp-129 + 0.5 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casinh (-0x1.fp-129 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.fp-129 - 0.5 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casinh (-0x1.fp-129 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.fp-30 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1.fp-30 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-105 + 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-105 - 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-112 + 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1p-112 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-112 - 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1p-112 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-23 + 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1p-23 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: casinh (-0x1p-23 + 0x0.ffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-23 + 0x1.000002p0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-23 - 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1p-23 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: casinh (-0x1p-23 - 0x0.ffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p-23 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-0x1p-52 + 0.5 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casinh (-0x1p-52 - 0.5 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (-0x1p-63 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p500 - 1.0 i) == -3.472667374605326000180332928505464606058e2 - 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p5000 + 1.0 i) == -3.466429049980286492395577839412341016946e3 + 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (-0x1p-63 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p5000 - 1.0 i) == -3.466429049980286492395577839412341016946e3 - 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-0x1p500 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p500 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p5000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-0x1p5000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Real part of: casinh (-1.0 + 0x1p500 i) == -3.472667374605326000180332928505464606058e2 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 + 0.25 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + 0.5 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1p5000 i) == -3.466429049980286492395577839412341016946e3 + 1.570796326794896619231321691639751442099 i": +Test "Imaginary part of: casinh (-1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-10 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + 0x1.fp-100 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + 0x1.fp-10000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + 0x1.fp-129 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + 0x1.fp-30 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 + 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Real part of: casinh (-1.0 - 0x1p500 i) == -3.472667374605326000180332928505464606058e2 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 - 0.25 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1p5000 i) == -3.466429049980286492395577839412341016946e3 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 - 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-1.0 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 - 0x1.fp-10 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 - 0x1.fp-100 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 - 0x1.fp-10000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-129 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 - 0x1.fp-30 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 - 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.0 - 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (-1.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-16385 i) == -1.194763217287109304111930828519090523536 + 4.516698239814521372306784062043266700598e-4933 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-16385 i) == -1.194763217287109304111930828519090523536 - 4.516698239814521372306784062043266700598e-4933 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Imaginary part of: casinh (0.0 + 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0.0 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.0 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0.0 - 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0.0 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.0 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0.25 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0.25 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 + +0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 + 0x1.fp-129 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 + 0x1p-105 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (0.5 + 0x1p-112 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (0.5 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casinh (0.5 + 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Real part of: casinh (0.5 + 0x1p-52 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0.5 + 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 + 0x1p-63 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (0.5 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casinh (0.5 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (0.5 - 0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 - 0x1.fp-129 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 - 0x1p-105 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (0.5 - 0x1p-112 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (0.5 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Imaginary part of: casinh (0.5 - 0x1p-23 i)": +float: 1 +ifloat: 1 +ildouble: 2 +ldouble: 2 +Test "Real part of: casinh (0.5 - 0x1p-52 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0.5 - 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0.5 - 0x1p-63 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (0.5 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: casinh (0.5 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": +double: 1 float: 1 +idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 + 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.0000000000000000000000000001p0 + 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 - 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.0000000000000000000000000001p0 - 0x1p-113 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000002p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000002p0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000002p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000002p0 - 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000001p0 + 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000001p0 + 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.0000000000001p0 + 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000001p0 - 0.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.0000000000001p0 - 0x1.fp-1025 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.0000000000001p0 - 0x1p-52 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i)": +double: 1 float: 1 +idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp-10 + 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.fp-10 - 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.fp-129 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Imaginary part of: casinh (0x1.fp-129 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.fp-129 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp16383 + 0x1.fp16383 i) == 1.135753137836666928715489992987020363057e4 + 7.853981633974483096156608458198757210493e-1 i": +Test "Imaginary part of: casinh (0x1.fp-129 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p500 + 1.0 i) == 3.472667374605326000180332928505464606058e2 + 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.fp-30 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.fp-30 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (0x1.fp16383 + 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-105 + 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-105 - 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-112 + 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1p-112 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-112 - 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1p-112 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-113 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-113 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-23 + 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1p-23 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: casinh (0x1p-23 + 0x0.ffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-23 + 0x1.000002p0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-23 - 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1p-23 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i)": +float: 2 +ifloat: 2 +Test "Imaginary part of: casinh (0x1p-23 - 0x0.ffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-23 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (0x1p-52 + 0.5 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casinh (0x1p-52 - 0.5 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i)": +double: 1 +idouble: 1 +Test "Real part of: casinh (0x1p-63 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-63 - 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p500 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p500 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p5000 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (0x1p5000 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + +0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0.25 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0.5 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (1.0 + 0.5 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0x1.fp-10 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0x1.fp-100 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0x1.fp-1000 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0x1.fp-10000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0x1.fp-1025 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0x1.fp-129 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0x1.fp-30 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 + 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 - 0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 - 0.25 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p500 - 1.0 i) == 3.472667374605326000180332928505464606058e2 - 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (1.0 - 0.5 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p5000 + 1.0 i) == 3.466429049980286492395577839412341016946e3 + 7.079811261048172892385615158694057552948e-1506 i": +Test "Imaginary part of: casinh (1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p5000 - 1.0 i) == 3.466429049980286492395577839412341016946e3 - 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (1.0 - 0x1.fp-10 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1p500 i) == 3.472667374605326000180332928505464606058e2 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1000 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 - 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1p5000 i) == 3.466429049980286492395577839412341016946e3 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1025 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1p500 i) == 3.472667374605326000180332928505464606058e2 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1p5000 i) == 3.466429049980286492395577839412341016946e3 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 - 0x1.fp-30 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.0 - 0x1p500 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.0 - 0x1p5000 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-16385 i) == 1.194763217287109304111930828519090523536 + 4.516698239814521372306784062043266700598e-4933 i": +Test "Real part of: casinh (1.5 + 0x1.fp-129 i)": +double: 1 +idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 + 0x1.fp-16385 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-16385 i) == 1.194763217287109304111930828519090523536 - 4.516698239814521372306784062043266700598e-4933 i": +Test "Real part of: casinh (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i)": +double: 1 +idouble: 1 +Test "Real part of: catan (-0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-16382 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-57 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (-0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-16382 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (-0x0.ffffffp0 + 0x1p-126 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (-0x0.ffffffp0 - 0x1p-126 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-0x1.0000000000000000000000000001p0 + 0x1p-16382 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-0x1.0000000000000000000000000001p0 - 0x1p-16382 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-0x1.0000000000000000000000000001p0 - 0x1p-57 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-0x1.0000000000001p0 - 0x1p-27 i)": +double: 1 +idouble: 1 +Test "Real part of: catan (-0x1.000002p0 + 0x1p-126 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (-0x1.000002p0 + 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Real part of: catan (-0x1.000002p0 - 0x1p-126 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (-0x1.000002p0 - 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (-0x1.fp16383 + 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-0x1.fp16383 - 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i)": +double: 1 +idouble: 1 +Test "Real part of: catan (-0x1p-13 + 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Real part of: catan (-0x1p-13 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: catan (-0x1p-13 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (-0x1p-13 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Real part of: catan (-0x1p-13 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (-0x1p-16380 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-0x1p-16380 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (-0x1p-33 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (-0x1p-33 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (-0x1p-33 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (-0x1p-33 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-0x1p-54 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (-0x1p-54 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (-0x1p-57 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (-0x1p-57 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: catan (-1.0 + 0x1p-13 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (-1.0 - 0x1p-13 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (-2 - 3 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "Imaginary part of: catan (0.75 + 1.25 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i)": +double: 1 +idouble: 1 +Test "Real part of: catan (0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-16382 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-57 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-16382 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (0x0.ffffffp0 + 0x1p-126 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (0.75 + 1.25 i) == 1.10714871779409050301706546017853704 + 0.549306144334054845697622618461262852 i": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (0x0.ffffffp0 - 0x1p-126 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x1.0000000000000000000000000001p0 + 0x1p-16382 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x1.0000000000000000000000000001p0 - 0x1p-16382 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x1.0000000000000000000000000001p0 - 0x1p-57 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x1.0000000000001p0 - 0x1p-27 i)": +double: 1 +idouble: 1 +Test "Real part of: catan (0x1.000002p0 + 0x1p-126 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (0x1.000002p0 + 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Real part of: catan (0x1.000002p0 - 0x1p-126 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (0x1.000002p0 - 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (0x1.fp16383 + 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x1.fp16383 - 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x1p-1020 + 1.0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catan (0x1p-1020 - 1.0 i)": +double: 1 +idouble: 1 +Test "Real part of: catan (0x1p-13 + 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Real part of: catan (0x1p-13 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: catan (0x1p-13 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (0x1p-13 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Real part of: catan (0x1p-13 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (0x1p-16380 + 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x1p-16380 - 1.0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (0x1p-33 + 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (0x1p-33 + 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (0x1p-33 - 0x0.ffffffffffffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (0x1p-33 - 0x1.0000000000000002p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catan (0x1p-54 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (0x1p-54 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (0x1p-57 + 1.0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catan (0x1p-57 - 1.0 i)": +float: 1 +ifloat: 1 +Test "Real part of: catan (1.0 + 0x1p-13 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: catan (1.0 - 0x1p-13 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Imaginary part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-33 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-33 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (-0x1.0000000000000002p0 + 0x1p-33 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (-0x1.0000000000000002p0 - 0x1p-33 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-0x1.000002p0 + 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catanh (-0x1.000002p0 + 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (-0x1.000002p0 - 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catanh (-0x1.000002p0 - 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (-0x1.fp16383 + 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-0x1.fp16383 - 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (-0x1p-126 + 0x0.ffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (-0x1p-126 + 0x1.000002p0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (-0x1p-126 - 0x0.ffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (-0x1p-126 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catanh (-0x1p-13 + 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catanh (-0x1p-13 + 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catanh (-0x1p-13 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catanh (-0x1p-13 - 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (-0x1p-16382 + 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-0x1p-16382 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (-0x1p-16382 - 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-0x1p-16382 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-0x1p-27 + 0x1.0000000000001p0 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (-0x1p-27 - 0x1.0000000000001p0 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (-0x1p-57 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-0x1p-57 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-1.0 + 0x1p-1020 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catanh (-1.0 + 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (-1.0 + 0x1p-16380 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-1.0 + 0x1p-54 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (-1.0 + 0x1p-57 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (-1.0 - 0x1p-1020 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catanh (-1.0 - 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (-1.0 - 0x1p-16380 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (-1.0 - 0x1p-54 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (-1.0 - 0x1p-57 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (0.75 + 1.25 i)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0.75 + 1.25 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-33 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-33 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x1.0000000000000002p0 + 0x1p-33 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x1.0000000000000002p0 - 0x1p-33 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x1.000002p0 + 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catanh (0x1.000002p0 - 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (0x1.fp16383 + 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (0x1.fp16383 - 0x1.fp16383 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x1p-126 + 0x0.ffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x1p-126 + 0x1.000002p0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x1p-126 - 0x0.ffffffp0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x1p-126 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i)": double: 1 +float: 1 idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x1p-13 + 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catanh (0x1p-13 + 1.0 i)": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 ildouble: 1 ldouble: 1 +Test "Imaginary part of: catanh (0x1p-13 - 0x1.000002p0 i)": +float: 1 +ifloat: 1 +Test "Imaginary part of: catanh (0x1p-13 - 1.0 i)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x1p-16382 + 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (0x1p-16382 + 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Imaginary part of: catanh (0x1p-16382 - 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (0x1p-16382 - 0x1.0000000000000000000000000001p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i)": +double: 1 +idouble: 1 +Test "Real part of: catanh (0x1p-57 + 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (0x1p-57 - 0x0.ffffffffffffffffffffffffffff8p0 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (1.0 + 0x1p-1020 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catanh (1.0 + 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (1.0 + 0x1p-16380 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (1.0 + 0x1p-54 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (1.0 + 0x1p-57 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (1.0 - 0x1p-1020 i)": +double: 1 +idouble: 1 +Test "Imaginary part of: catanh (1.0 - 0x1p-13 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (1.0 - 0x1p-16380 i)": +ildouble: 1 +ldouble: 1 +Test "Real part of: catanh (1.0 - 0x1p-54 i)": +float: 1 +ifloat: 1 +Test "Real part of: catanh (1.0 - 0x1p-57 i)": +float: 1 +ifloat: 1 # cbrt -Test "cbrt (-0.001) == -0.1": +Test "cbrt (-0.001)": ildouble: 1 ldouble: 1 -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 11357.25 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (-0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 11357.25 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (-0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Real part of: ccos (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 11357.25 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 11357.25 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0x1p-16434 + 22730 i) == inf - 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: ccos (0x1p-16434 + 22730 i)": ildouble: 1 ldouble: 1 # ccosh -Test "Imaginary part of: ccosh (-11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (-11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (-11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (22730 + 0x1p-16434 i) == inf + 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: ccosh (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cexp -Test "Imaginary part of: cexp (-10000 + 0x1p16383 i) == 1.045876464564882298442774542991176546722e-4343 + 4.421154026488516836023811173959413420548e-4344 i": +Test "Imaginary part of: cexp (-10000 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Real part of: cexp (-2.0 - 3.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-720 + 0.75 i) == 1.486960657116368433685753325516638551722e-313 + 1.385247284245720590980701226843815229385e-313 i": +Test "Imaginary part of: cexp (-720 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (22730 + 0x1p-16434 i) == inf + 2.435706297811211974162115164702304105374e4924 i": +Test "Imaginary part of: cexp (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16494 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16494 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16494 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16494 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16494 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16494 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 709.8942846690411016323109979483151967689 + 0.4636476090008061606231772164674799632783 i": +Test "Imaginary part of: clog (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i) == 11356.83823118610934184548269774874545400 + pi/4 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16494 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16494 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 3.2047474274603604594851472963586149973093e-29 + 1.4422922682185099608731642353544207976604 i": +Test "Imaginary part of: clog (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16494 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16494 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16494 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16494 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i) == -1.1931267660846218205882675852805793644095e-36 + 1.2402109774337032400594953899784058127412 i": +Test "Imaginary part of: clog (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2ede88p-23 + 0x771c3fp-23 i) == -4.4764192352906350039050902870893173560494e-13 + 1.1959106857549200806818600493552847793381 i": +Test "Imaginary part of: clog (0x2ede88p-23 + 0x771c3fp-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i) == -1.0509738482436128031927971874674370984602e-45 + 1.0509191467640012308402149909370784281448 i": +Test "Imaginary part of: clog (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x4d4ep-15 + 0x6605p-15 i) == -1.6298145321400412054744424587143483169412e-08 + 0.9223574537155056772124552172295398141249 i": +Test "Imaginary part of: clog (0x4d4ep-15 + 0x6605p-15 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i) == -5.2000108498455368032511404449795741611813e-32 + 1.5288921536982513453421343495466824420259 i": +Test "Imaginary part of: clog (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 8.3076914081087805757422664530653247447136e-30 + 1.2072712126771536614482822173033535043206 i": +Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x659feap-24 + 0xeaf6f9p-24 i) == 3.7303493627403868207597214252239749960738e-14 + 1.1625816408046866464773042283673653469061 i": +Test "Imaginary part of: clog (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6771f22c64ed551b857c128b4cp-105 + 0x1f570e7a13cc3cf2f44fd793ea1p-105 i) == -1.4281333889622737316199756373421183559948e-62 + 1.3673546561165378090903506783353927980633 i": +Test "Imaginary part of: clog (0x6771f22c64ed551b857c128b4cp-105 + 0x1f570e7a13cc3cf2f44fd793ea1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 2.4244570985709679851855191080208817099132e-37 + 1.1393074519572050614551047548718495655972 i": +Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i) == -9.7375017988218644730510244778042114638107e-30 + 0.9790637929494922564724108399524154766631 i": +Test "Real part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x9b57bp-20 + 0xcb7b4p-20 i) == -3.9563019528687610863490232935890272740908e-11 + 0.9187593477446338910857133065497364950682 i": +Test "Imaginary part of: clog (0x9b57bp-20 + 0xcb7b4p-20 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i) == 4.6017338806965821566734340588575402712716e-67 + 1.3547418904611758959096647942223384691728 i": +Test "Imaginary part of: clog (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i) == 6.6255694866654064502633121109394710807528e-66 + 1.0526409614996288387567810726095850312049 i": +Test "Imaginary part of: clog (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 5.3718272201930019901317065495843842735179e-26 + 1.0503831592447830576186444373011142397404 i": +Test "Imaginary part of: clog (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Real part of: clog10 (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Imaginary part of: clog10 (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i) == 4.285899851347756186652871946325962330640e-19 + 4.611541215247321502041995872887317363241e-302 i": +Test "Real part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i) == 4.285899851347756186652871946325962330640e-19 + 4.611541215247321502041995872887317363241e-302 i": +Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-60 i) == 4.285899851347756188767674032946882584784e-19 + 4.285899850759344225805480528847018395861e-19 i": +Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-60 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Real part of: clog10 (0x1.234566p-50 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Real part of: clog10 (0x1.234566p-60 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 308.4052305577487344482591243175787477115 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 308.3031705664207720674749211936626341569 + 0.2013595981366865903254995612594728746470 i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i) == 4932.212175672014259683102930239951947672 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i) == 4932.112944269463028900262609694408579449 + 0.2069271710841128115912940666587802677383 i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1415bcaf2105940d49a636e98ae59p-115 + 0x7e6a150adfcd1b0921d44b31f40f4p-115 i) == 1.1288799405048268615023706955013387413519e-67 + 0.6137587762850841972073301550420510507903 i": +Test "Real part of: clog10 (0x1415bcaf2105940d49a636e98ae59p-115 + 0x7e6a150adfcd1b0921d44b31f40f4p-115 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i) == 4.4163015461643576961232672330852798804976e-31 + 0.3564851427422832755956993418877523303529 i": +Test "Imaginary part of: clog10 (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Real part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i) == -322.8546703496198318667349645920187712089 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i) == -4.5643214291682663316715446865040356750881e-46 + 0.4564083863660793840592614609053162690362 i": +Test "Imaginary part of: clog10 (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Imaginary part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i) == 2.7822833698845776001753149807484078521508e-37 + 0.3992725998539071066769046272515417679815 i": +Test "Real part of: clog10 (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i) == -2.2583360179249556400630343805573865814771e-32 + 0.6639894257763289307423302343317622430835 i": +Test "Real part of: clog10 (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i) == -1.0146400362652473358437501879334790111898e-37 + 0.5149047982335273098246594109614460842099 i": +Test "Real part of: clog10 (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i) == 1.8804859395820231849002915747252695375405e-63 + 0.6404513901551516189871978418046651877394 i": +Test "Real part of: clog10 (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Real part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 1.0529283395205396881397407610630442563938e-37 + 0.4947949395762683446121140513971996916447 i": +Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i) == 1.9985076315737626043096596036300177494613e-67 + 0.5883569274304683249184005177865521205198 i": +Test "Real part of: clog10 (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i) == 2.8774482675253468630312378575186855052697e-66 + 0.4571561610046221605554903008571429975493 i": +Test "Imaginary part of: clog10 (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 @@ -1720,192 +6857,192 @@ ildouble: 1 ldouble: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 -Test "cos_downward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_downward (10)": ildouble: 1 ldouble: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_downward (6)": ildouble: 1 ldouble: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cos_towardzero -Test "cos_towardzero (10) == -0.8390715290764524522588639478240648345199": +Test "cos_towardzero (10)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (6) == 0.9601702866503660205456522979229244054519": +Test "cos_towardzero (6)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cos_upward -Test "cos_upward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_upward (1)": ildouble: 1 ldouble: 1 -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 -Test "cos_upward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_upward (4)": ildouble: 1 ldouble: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_tonearest -Test "cosh_tonearest (22) == 1792456423.065795780980053377632656584997": +Test "cosh_tonearest (22)": ildouble: 1 ldouble: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_upward -Test "cosh_upward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_upward (22)": ildouble: 1 ldouble: 1 -Test "cosh_upward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_upward (23)": ildouble: 1 ldouble: 1 -Test "cosh_upward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_upward (24)": ildouble: 1 ldouble: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 4 ldouble: 4 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 ildouble: 2 ldouble: 2 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 5 idouble: 1 ifloat: 5 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 @@ -1914,902 +7051,917 @@ ildouble: 1 ldouble: 1 # csin -Test "Real part of: csin (-0.75 + 11357.25 i) == -8.385498349388321535962327491346664141020e4931 + 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (-0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 11357.25 i) == -8.385498349388321535962327491346664141020e4931 - 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (-0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-2 - 3 i) == -9.15449914691142957346729954460983256 + 4.16890695996656435075481305885375484 i": +Test "Imaginary part of: csin (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Real part of: csin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 11357.25 i) == 8.385498349388321535962327491346664141020e4931 + 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 11357.25 i) == 8.385498349388321535962327491346664141020e4931 - 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 -Test "Real part of: csin (0x1p-16434 + 22730 i) == 1.217853148905605987081057582351152052687e4924 + inf i": +Test "Real part of: csin (0x1p-16434 + 22730 i)": ildouble: 1 ldouble: 1 # csinh -Test "Imaginary part of: csinh (-11357.25 + 0.75 i) == -9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (-11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-11357.25 - 0.75 i) == -9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (-11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Real part of: csinh (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (22730 + 0x1p-16434 i) == inf + 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: csinh (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # csqrt -Test "Real part of: csqrt (-0x1.0000000000000000000000000001p-16382 - 0x1.0000000000000000000000000001p-16382 i) == 8.344545284118961663847948339519226074126e-2467 - 2.014551439675644900022606748976158925145e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000000000000000001p-16382 - 0x1.0000000000000000000000000001p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i) == 6.788430486774966350907249113759995429568e-155 - 1.638872094839911521020410942677082920935e-154 i": +Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0.75 + 1.25 i) == 1.05065169626078392338656675760808326 + 0.594868882070379067881984030639932657 i": +Test "Imaginary part of: csqrt (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i) == 2.014551439675644900022606748976158925145e-2466 + 8.344545284118961663847948339519226074126e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i) == 1.638872094839911521020410942677082920935e-154 + 6.788430486774966350907249113759995429568e-155 i": +Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Real part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1p+16383 i) == 1.106698967236475180613254276996359485630e+2466 + 2.687568007603946993388538156299100955642e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-16440 + 0x1p-16441 i) == 3.514690655930285351254618340783294558136e-2475 + 8.297059146828716918029689466551384219370e-2476 i": +Test "Imaginary part of: csqrt (0x1p-16440 + 0x1p-16441 i)": ildouble: 1 ldouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Real part of: ctan (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Imaginary part of: ctan (0x1p1023 + 1 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Real part of: ctan (0x1p127 + 1 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Real part of: ctan (0x1p16383 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Imaginary part of: ctan (0x1p16383 + 1 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 355 i) == 8.140551093483276762350406321792653551513e-309 + 1.0 i": +Test "Real part of: ctan (1 + 355 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 365 i) == 1.677892637497921890115075995898773550884e-317 + 1.0 i": +Test "Real part of: ctan (1 + 365 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 45 i) == 1.490158918874345552942703234806348520895e-39 + 1.000000000000000000000000000000000000001 i": +Test "Real part of: ctan (1 + 45 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 47 i) == 2.729321264492904590777293425576722354636e-41 + 1.0 i": +Test "Real part of: ctan (1 + 47 i)": ildouble: 1 ldouble: 1 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 # ctan_tonearest -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 ifloat: 2 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Real part of: ctanh (1 + 0x1p1023 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Imaginary part of: ctanh (1 + 0x1p127 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Real part of: ctanh (1 + 0x1p16383 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Imaginary part of: ctanh (1 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (355 + 1 i) == 1.0 + 8.140551093483276762350406321792653551513e-309 i": +Test "Imaginary part of: ctanh (355 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (365 + 1 i) == 1.0 + 1.677892637497921890115075995898773550884e-317 i": +Test "Imaginary part of: ctanh (365 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (45 + 1 i) == 1.000000000000000000000000000000000000001 + 1.490158918874345552942703234806348520895e-39 i": +Test "Imaginary part of: ctanh (45 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (47 + 1 i) == 1.0 + 2.729321264492904590777293425576722354636e-41 i": +Test "Imaginary part of: ctanh (47 + 1 i)": ildouble: 1 ldouble: 1 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 4 ldouble: 4 -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 2 ldouble: 2 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_upward -Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0.75) == 0.288844366346484868401062165408589223": +Test "erfc (0.75)": float: 1 ifloat: 1 -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "erfc (0x1.ffffc8p+2) == 1.122671365033056305522366683719541099329e-29": +Test "erfc (0x1.ffffc8p+2)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (27.0) == 0.523704892378925568501606768284954709e-318": +Test "erfc (27.0)": ildouble: 1 ldouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 1 idouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 1 idouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 -Test "exp10 (4932) == 1.0e4932": +Test "exp10 (4932)": ildouble: 1 ldouble: 1 # exp2 -Test "exp2 (100.5) == 1.792728671193156477399422023278661496394e+30": +Test "exp2 (100.5)": ildouble: 1 ldouble: 1 # exp_downward -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_towardzero -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # expm1 -Test "expm1 (-79.0) == -0.9999999999999999999999999999999999509391": +Test "expm1 (-79.0)": ildouble: 1 ldouble: 1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # gamma -Test "gamma (-0.5) == log(2*sqrt(pi))": +Test "gamma (-0.5)": ildouble: 1 ldouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-0x1.001000001p+593) == -3.927269966354206207832593635798954916263e-90": +Test "j0 (-0x1.001000001p+593)": ildouble: 1 ldouble: 1 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (0x1p1023)": +ildouble: 1 +ldouble: 1 +Test "j0 (0x1p16383)": +ildouble: 2 +ldouble: 2 +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": ildouble: 2 ldouble: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # j1 -Test "j1 (-1.0) == -0.440050585744933515959682203718914913": +Test "j1 (-1.0)": ildouble: 1 ldouble: 1 -Test "j1 (0.75) == 0.349243602174862192523281016426251335": +Test "j1 (0.75)": ildouble: 1 ldouble: 1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (1.0) == 0.440050585744933515959682203718914913": +Test "j1 (0x1p1023)": +ildouble: 1 +ldouble: 1 +Test "j1 (0x1p16382)": +ildouble: 1 +ldouble: 1 +Test "j1 (0x1p16383)": +ildouble: 2 +ldouble: 2 +Test "j1 (1.0)": ildouble: 1 ldouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": ildouble: 2 ldouble: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (1, -1.0) == -0.440050585744933515959682203718914913": +Test "jn (1, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (1, 0.75) == 0.349243602174862192523281016426251335": +Test "jn (1, 0.75)": ildouble: 1 ldouble: 1 -Test "jn (1, 1.0) == 0.440050585744933515959682203718914913": +Test "jn (1, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 idouble: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 5 ldouble: 5 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 ildouble: 3 ldouble: 3 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 ildouble: 8 ldouble: 8 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 @@ -2818,17 +7970,17 @@ ildouble: 3 ldouble: 3 # lgamma -Test "lgamma (-0.5) == log(2*sqrt(pi))": +Test "lgamma (-0.5)": ildouble: 1 ldouble: 1 -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -2837,409 +7989,1254 @@ ildouble: 1 ldouble: 1 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # log2 -Test "log2 (0.75) == -.415037499278843818546261056052183492": +Test "log2 (0.75)": ildouble: 1 ldouble: 1 # pow -Test "pow (0x0.fffffffffffff8p0, -0x1.23456789abcdfp62) == 9.8826311568054561811190162420900667121992e+252": +Test "pow (0x0.fffffffffffff8p0, -0x1.23456789abcdfp62)": ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (10.0, -4930.0) == 1e-4930": +Test "pow (10.0, -4930.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4929.0) == 1e4929": +Test "pow (10.0, 4929.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4930.0) == 1e4930": +Test "pow (10.0, 4930.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4931.0) == 1e4931": +Test "pow (10.0, 4931.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4932.0) == 1e4932": +Test "pow (10.0, 4932.0)": ildouble: 1 ldouble: 1 -Test "pow (1e4932, 0.75) == 1e3699": +Test "pow (1e4932, 0.75)": ildouble: 1 ldouble: 1 # pow_downward -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 # pow_towardzero -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_downward -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 -Test "sin_downward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_downward (2)": ildouble: 1 ldouble: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_downward (4)": ildouble: 1 ldouble: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 -Test "sin_downward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_downward (8)": ildouble: 1 ldouble: 1 -Test "sin_downward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_downward (9)": ildouble: 1 ldouble: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 -Test "sin_tonearest (3) == 0.1411200080598672221007448028081102798469": +Test "sin_tonearest (3)": ildouble: 1 ldouble: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (2) == 0.9092974268256816953960198659117448427023": +Test "sin_towardzero (2)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (3) == 0.1411200080598672221007448028081102798469": +Test "sin_towardzero (3)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (8) == 0.9893582466233817778081235982452886721164": +Test "sin_towardzero (8)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_upward (10)": ildouble: 1 ldouble: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 -Test "sin_upward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_upward (3)": ildouble: 1 ldouble: 1 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 -Test "sin_upward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_upward (6)": ildouble: 1 ldouble: 1 -Test "sin_upward (7) == 0.6569865987187890903969990915936351779369": +Test "sin_upward (7)": ildouble: 1 ldouble: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 # sinh_upward -Test "sinh_upward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_upward (22)": ildouble: 1 ldouble: 1 -Test "sinh_upward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_upward (23)": ildouble: 1 ldouble: 1 -Test "sinh_upward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_upward (24)": ildouble: 1 ldouble: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_towardzero -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (6) == -0.2910061913847491570536995888681755428312": +Test "tan_towardzero (6)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # tan_upward -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": ildouble: 1 ldouble: 1 -Test "tan_upward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_upward (2)": ildouble: 1 ldouble: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (4) == 1.1578212823495775831373424182673239231198": +Test "tan_upward (4)": ildouble: 1 ldouble: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_upward (6)": ildouble: 1 ldouble: 1 -Test "tan_upward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_upward (9)": ildouble: 1 ldouble: 1 # tanh -Test "tanh (-0.75) == -0.635148952387287319214434357312496495": +Test "tanh (-0.75)": ildouble: 1 ldouble: 1 -Test "tanh (-1.0) == -0.7615941559557648881194582826047935904": +Test "tanh (-1.0)": ildouble: 1 ldouble: 1 -Test "tanh (0.75) == 0.635148952387287319214434357312496495": +Test "tanh (0.75)": ildouble: 1 ldouble: 1 -Test "tanh (1.0) == 0.7615941559557648881194582826047935904": +Test "tanh (1.0)": ildouble: 1 ldouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x0.fffffffffffff8p0)": +double: 1 +idouble: 1 +Test "tgamma (-0x0.ffffffffffffffffffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x0.ffffffp0)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1.0000000000000002p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1.0000000000001p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1.000002p0)": +double: 2 +idouble: 2 +Test "tgamma (-0x1.0a32a2p+5)": +float: 2 +ifloat: 2 +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x1.5800000080001p+7)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1.fffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1.fffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x13.ffffep0)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x13.ffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x13.fffffffffffffffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x13.ffffffffffffp0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x14.000000000000000000000000001p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x14.000000000001p0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x14.00002p0)": +float: 1 +ifloat: 1 +ildouble: 4 +ldouble: 4 +Test "tgamma (-0x1d.ffffep0)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1d.fffffffffffffffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1d.ffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1e.000000000000000000000000001p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x1e.00000000000000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1e.000000000000002p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1e.000000000001p0)": +double: 3 +idouble: 3 +Test "tgamma (-0x1e.00002p0)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1f3.ffffffffffffffffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x1p-24)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x2.0000000000000000000000000002p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x2.0000000000002p0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x2.000004p0)": +double: 2 +float: 1 +idouble: 2 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x2.fffffcp0)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (-0x2.ffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x27.fffffffffffep0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x27.ffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x27.ffffffffffffffffffffffffffep0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x27.fffffffffffffffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x28.0000000000000000000000001p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x28.000000000002p0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x28.00004p0)": +double: 2 +idouble: 2 +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x28.ffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x28.ffffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x28.fffffffffffffffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x29.000000000000000000000000002p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x29.0000000000000000000000001p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x29.00004p0)": +double: 1 +idouble: 1 +Test "tgamma (-0x29.ffffcp0)": +double: 1 +idouble: 1 +Test "tgamma (-0x29.fffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x29.ffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x29.ffffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x29.fffffffffffffffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x2a.000000000000000000000000002p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x2a.0000000000000000000000001p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x2a.000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x2a.000000000002p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x2ed.fffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x2ee.00000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x3.00000000000000000000000001p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x3.000004p0)": +double: 2 +float: 1 +idouble: 2 +ifloat: 1 +Test "tgamma (-0x3.fffffcp0)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (-0x3.ffffffffffffep0)": +double: 2 +idouble: 2 +Test "tgamma (-0x3.fffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x3.fffffffffffffffffffffffffffep0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x31.fffffffffffep0)": +double: 3 +idouble: 3 +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x31.ffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x31.ffffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x31.fffffffffffffffffffffffffp0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x32.000000000000000000000000002p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x32.0000000000000000000000001p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x32.000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x3e7.fffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x3e7.fffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x3e8.00000000000000000000000002p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x3e8.00000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x4.0000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x4.000008p0)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x4.fffff8p0)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (-0x4.ffffffffffffcp0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x4.fffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x4.fffffffffffffffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x5.0000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x5.0000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x5.000008p0)": +double: 1 +float: 2 +idouble: 1 +ifloat: 2 +Test "tgamma (-0x5.fffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x5.ffffffffffffcp0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x5.fffffffffffffff8p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x5.fffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x5.fffffffffffffffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x5db.fffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x5db.fffffffffffffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x5dc.00000000000000000000000004p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x6.0000000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x6.00000000000000000000000002p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x6.0000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x6.000008p0)": +float: 2 +ifloat: 2 +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x6.fffff8p0)": +double: 2 +float: 1 +idouble: 2 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x6.ffffffffffffcp0)": +double: 4 +idouble: 4 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x6.fffffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x6.fffffffffffffffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x63.fffffffffffcp0)": +double: 2 +idouble: 2 +Test "tgamma (-0x63.ffffffffffffff8p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x63.ffffffffffffffffffffffffep0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x64.000000000000000000000000004p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x64.0000000000000000000000002p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x64.000000000004p0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x6d5.fffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x6d6.00000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x6e3.00000000000000000000000004p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x7.0000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x7.0000000000004p0)": +double: 3 +idouble: 3 +Test "tgamma (-0x7.000008p0)": +double: 1 +idouble: 1 +Test "tgamma (-0x7.fffff8p0)": +double: 3 +float: 1 +idouble: 3 +ifloat: 1 +Test "tgamma (-0x7.ffffffffffffcp0)": +double: 3 +idouble: 3 +Test "tgamma (-0x7.fffffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x7.fffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x7.fffffffffffffffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x8.0000000000000000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x8.00000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x8.0000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x8.00001p0)": +double: 2 +idouble: 2 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x9.ffffffffffff8p0)": +double: 1 +idouble: 1 +Test "tgamma (-0x9.fffffffffffffffffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x95.ffffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x96.000000000000000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x96.0000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0x96.00000000000001p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0x96.000000000008p0)": +double: 1 +idouble: 1 +Test "tgamma (-0xa.0000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xa.00001p0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb4.ffffffffffffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb4.ffffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb5.0000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb5.00000000000001p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0xb5.000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb5.ffffffffffffffffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb6.00000000000001p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb6.000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb6.fffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb6.ffffffffffffffffffffffffff8p0)": +ildouble: 3 +ldouble: 3 +Test "tgamma (-0xb7.000000000000000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb7.00000000000001p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0xb7.000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb7.ffffffffffffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb7.ffffffffffffffffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xb8.00000000000001p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xbb.ffffffffffffffffffffffffcp0)": +ildouble: 3 +ldouble: 3 +Test "tgamma (-0xbb.ffffffffffffffffffffffffff8p0)": +ildouble: 4 +ldouble: 4 +Test "tgamma (-0xbc.000000000000000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xbc.0000000000000000000000004p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0xbc.00000000000001p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0xbc.ffffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xbd.000000000000000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xbd.00000000000001p0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0xbd.ffffffffffffffp0)": +ildouble: 2 +ldouble: 2 +Test "tgamma (-0xbe.000000000000000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xbe.0000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xbe.ffffffffffffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xbe.ffffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xbf.000000000000000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xbf.0000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xbf.00000000000001p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xf9.ffffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-0xfa.000000000000000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (-2.5)": +double: 1 +float: 2 +idouble: 1 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "tgamma (-3.5)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-4.5)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (-5.5)": +double: 1 +idouble: 1 +Test "tgamma (-6.5)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (-7.5)": +double: 2 +float: 1 +idouble: 2 +ifloat: 1 +Test "tgamma (-8.5)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (-9.5)": +double: 1 +float: 2 +idouble: 1 +ifloat: 2 +Test "tgamma (0.5)": +float: 1 +ifloat: 1 +Test "tgamma (0.7)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (0x1.fffffep0)": +float: 1 +ifloat: 1 +Test "tgamma (0x1.fffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x1.ffffffffffffffffffffffffffffp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x1.fffffffffffffp0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (0x1p-113)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x1p-24)": +float: 1 +ifloat: 1 +Test "tgamma (0x1p-53)": +double: 1 +idouble: 1 +Test "tgamma (0x2.30a43cp+4)": +double: 1 +idouble: 1 +ildouble: 2 +ldouble: 2 +Test "tgamma (0x2.fffffcp0)": +float: 3 +ifloat: 3 +Test "tgamma (0x2.ffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x3.0000000000002p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x3.fffffcp0)": +float: 1 +ifloat: 1 +Test "tgamma (0x3.ffffffffffffep0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (0x3.fffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x3.fffffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x4.0000000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x4.0000000000004p0)": +double: 1 +idouble: 1 +Test "tgamma (0x4.000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x4.fffff8p0)": +float: 1 +ifloat: 1 +Test "tgamma (0x4.ffffffffffffcp0)": +double: 1 +idouble: 1 +Test "tgamma (0x4.fffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x4.fffffffffffffffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x5.0000000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x5.0000000000004p0)": +double: 1 +idouble: 1 +Test "tgamma (0x5.000008p0)": +float: 3 +ifloat: 3 +Test "tgamma (0x5.fffff8p0)": double: 1 float: 1 idouble: 1 ifloat: 1 +Test "tgamma (0x5.ffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x5.fffffffffffffff8p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x5.fffffffffffffffffffffffffep0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x6.0000000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x6.0000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x6.0000000000004p0)": +double: 1 +idouble: 1 +Test "tgamma (0x6.000008p0)": +float: 2 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "tgamma (0x6.fffff8p0)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (0x6.ffffffffffffcp0)": +double: 4 +idouble: 4 +Test "tgamma (0x6.fffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0x7.0000000000000000000000000004p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x7.0000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x7.0000000000004p0)": +double: 4 +idouble: 4 +Test "tgamma (0x7.000008p0)": +double: 1 +idouble: 1 +Test "tgamma (0x7.fffff8p0)": +double: 2 float: 1 +idouble: 2 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0x7.ffffffffffffcp0)": +double: 2 +idouble: 2 +ildouble: 1 +ldouble: 1 +Test "tgamma (0x7.fffffffffffffffffffffffffffcp0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x8.0000000000000000000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x8.0000000000008p0)": +ildouble: 1 +ldouble: 1 +Test "tgamma (0x8.00001p0)": +double: 2 +idouble: 2 +Test "tgamma (0xa.b9fd72b0fb238p+4)": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (0xa.b9fd72b0fb23a9ddbf0d3804f8p+4)": +ildouble: 2 +ldouble: 2 +Test "tgamma (10)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (18.5)": +double: 1 +idouble: 1 +Test "tgamma (19.5)": +double: 2 +idouble: 2 +ildouble: 1 +ldouble: 1 +Test "tgamma (2.5)": +float: 2 +ifloat: 2 +Test "tgamma (23.5)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (29.5)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (3)": +float: 1 +ifloat: 1 +Test "tgamma (3.5)": +float: 2 +ifloat: 2 +ildouble: 1 +ldouble: 1 +Test "tgamma (32.5)": +ildouble: 1 +ldouble: 1 +Test "tgamma (33.5)": +ildouble: 1 +ldouble: 1 +Test "tgamma (34.5)": +double: 1 +idouble: 1 +Test "tgamma (4)": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 +Test "tgamma (4.5)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (6)": +float: 1 +ifloat: 1 +Test "tgamma (6.5)": +float: 1 +ifloat: 1 +Test "tgamma (7)": +double: 1 +idouble: 1 +Test "tgamma (7.5)": +double: 2 +float: 1 +idouble: 2 +ifloat: 1 +Test "tgamma (8)": +double: 1 +idouble: 1 +Test "tgamma (8.5)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "tgamma (9)": +double: 1 +idouble: 1 +Test "tgamma (9.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (4) == 6": ildouble: 1 ldouble: 1 # y0 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": ildouble: 1 ldouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": double: 1 idouble: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-60) == -2.6550076313426878432849115782108205929120e+1": +Test "y0 (0x1p-60)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 idouble: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (0x1p1023)": +ildouble: 1 +ldouble: 1 +Test "y0 (0x1p16382)": +ildouble: 1 +ldouble: 1 +Test "y0 (0x1p16383)": +ildouble: 2 +ldouble: 2 +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "y0 (2.0) == 0.510375672649745119596606592727157873": +Test "y0 (2.0)": double: 1 idouble: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -3248,44 +9245,50 @@ ildouble: 3 ldouble: 3 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0.75) == -1.03759455076928541973767132140642198": +Test "y1 (0.75)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.001000001p+593) == 3.927269966354206207832593635798954916263e-90": +Test "y1 (0x1.001000001p+593)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y1 (0x1p-30) == -6.8356527557643159612937462812258975438856e+08": +Test "y1 (0x1p-30)": +ildouble: 1 +ldouble: 1 +Test "y1 (0x1p1023)": ildouble: 1 ldouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (0x1p16383)": +ildouble: 2 +ldouble: 2 +Test "y1 (1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 @@ -3294,108 +9297,108 @@ ildouble: 1 ldouble: 1 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (0, 2.0) == 0.510375672649745119596606592727157873": +Test "yn (0, 2.0)": double: 1 idouble: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 0.75) == -1.03759455076928541973767132140642198": +Test "yn (1, 0.75)": ildouble: 1 ldouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 5 ldouble: 5 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 2 idouble: 2 ildouble: 2 ldouble: 2 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 @@ -3452,66 +9455,74 @@ ifloat: 1 Function: Real part of "cacos": double: 1 -float: 1 +float: 2 idouble: 1 -ifloat: 1 -ildouble: 1 -ldouble: 1 +ifloat: 2 +ildouble: 2 +ldouble: 2 Function: Imaginary part of "cacos": double: 2 -float: 1 +float: 2 idouble: 2 -ifloat: 1 -ildouble: 3 -ldouble: 3 +ifloat: 2 +ildouble: 2 +ldouble: 2 Function: Real part of "cacosh": double: 1 -float: 1 +float: 2 idouble: 1 -ifloat: 1 -ildouble: 1 -ldouble: 1 +ifloat: 2 +ildouble: 2 +ldouble: 2 Function: Imaginary part of "cacosh": double: 1 -float: 1 +float: 2 idouble: 1 -ifloat: 1 -ildouble: 1 -ldouble: 1 +ifloat: 2 +ildouble: 2 +ldouble: 2 Function: Real part of "casin": double: 1 float: 1 idouble: 1 ifloat: 1 +ildouble: 2 +ldouble: 2 Function: Imaginary part of "casin": double: 2 -float: 1 +float: 2 idouble: 2 -ifloat: 1 -ildouble: 3 -ldouble: 3 +ifloat: 2 +ildouble: 2 +ldouble: 2 Function: Real part of "casinh": double: 5 -float: 1 +float: 2 idouble: 5 -ifloat: 1 +ifloat: 2 ildouble: 4 ldouble: 4 Function: Imaginary part of "casinh": double: 3 -float: 6 +float: 1 idouble: 3 -ifloat: 6 +ifloat: 1 ildouble: 2 ldouble: 2 +Function: Real part of "catan": +float: 1 +ifloat: 1 +ildouble: 1 +ldouble: 1 + Function: Imaginary part of "catan": double: 1 float: 1 @@ -3522,11 +9533,15 @@ ldouble: 1 Function: Real part of "catanh": double: 4 +float: 1 idouble: 4 +ifloat: 1 ildouble: 1 ldouble: 1 Function: Imaginary part of "catanh": +float: 1 +ifloat: 1 ildouble: 1 ldouble: 1 @@ -4063,12 +10078,12 @@ ildouble: 1 ldouble: 1 Function: "tgamma": -double: 1 -float: 1 -idouble: 1 -ifloat: 1 -ildouble: 1 -ldouble: 1 +double: 4 +float: 3 +idouble: 4 +ifloat: 3 +ildouble: 4 +ldouble: 4 Function: "y0": double: 2 @@ -4083,8 +10098,8 @@ double: 3 float: 2 idouble: 3 ifloat: 2 -ildouble: 1 -ldouble: 1 +ildouble: 2 +ldouble: 2 Function: "yn": double: 3 diff --git a/libc/ports/sysdeps/aarch64/setjmp.S b/libc/ports/sysdeps/aarch64/setjmp.S index cff81c7e4..10e070999 100644 --- a/libc/ports/sysdeps/aarch64/setjmp.S +++ b/libc/ports/sysdeps/aarch64/setjmp.S @@ -44,8 +44,14 @@ ENTRY (__sigsetjmp) stp d10, d11, [x0, #JB_D10<<3] stp d12, d13, [x0, #JB_D12<<3] stp d14, d15, [x0, #JB_D14<<3] - mov x1, sp - str x1, [x0, #JB_SP<<3] + mov x2, sp + str x2, [x0, #JB_SP<<3] +#if defined NOT_IN_libc && defined IS_IN_rtld + /* In ld.so we never save the signal mask */ + mov w0, #0 + RET +#else b C_SYMBOL_NAME(__sigjmp_save) +#endif END (__sigsetjmp) hidden_def (__sigsetjmp) diff --git a/libc/ports/sysdeps/alpha/fpu/libm-test-ulps b/libc/ports/sysdeps/alpha/fpu/libm-test-ulps index d546515ea..149700358 100644 --- a/libc/ports/sysdeps/alpha/fpu/libm-test-ulps +++ b/libc/ports/sysdeps/alpha/fpu/libm-test-ulps @@ -1,19 +1,19 @@ # Begin of automatic generation # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 @@ -22,19 +22,19 @@ ildouble: 1 ldouble: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 @@ -43,182 +43,182 @@ ildouble: 1 ldouble: 1 # acos_upward -Test "acos_upward (-0) == pi/2": +Test "acos_upward (-0)": ildouble: 1 ldouble: 1 -Test "acos_upward (-1) == pi": +Test "acos_upward (-1)": ildouble: 1 ldouble: 1 -Test "acos_upward (0) == pi/2": +Test "acos_upward (0)": ildouble: 1 ldouble: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (-1.0) == -pi/2": +Test "asin_downward (-1.0)": ildouble: 1 ldouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 # asin_upward -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 -Test "asin_upward (1.0) == pi/2": +Test "asin_upward (1.0)": ildouble: 1 ldouble: 1 # atan2 -Test "atan2 (-0.00756827042671106339, -.001792735857538728036) == -1.80338464113663849327153994379639112": +Test "atan2 (-0.00756827042671106339, -.001792735857538728036)": ildouble: 1 ldouble: 1 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: cacos (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 @@ -227,199 +227,199 @@ ildouble: 1 ldouble: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: casin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 @@ -428,951 +428,951 @@ ildouble: 1 ldouble: 1 # casinh -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (0.75 + 1.25 i) == 1.10714871779409050301706546017853704 + 0.549306144334054845697622618461262852 i": +Test "Imaginary part of: catan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Imaginary part of: catanh (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 # cbrt -Test "cbrt (-0.001) == -0.1": +Test "cbrt (-0.001)": ildouble: 1 ldouble: 1 -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 11357.25 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (-0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 11357.25 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (-0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Real part of: ccos (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 11357.25 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 11357.25 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0x1p-16434 + 22730 i) == inf - 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: ccos (0x1p-16434 + 22730 i)": ildouble: 1 ldouble: 1 # ccosh -Test "Imaginary part of: ccosh (-11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (-11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (-11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (22730 + 0x1p-16434 i) == inf + 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: ccosh (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cexp -Test "Imaginary part of: cexp (-10000 + 0x1p16383 i) == 1.045876464564882298442774542991176546722e-4343 + 4.421154026488516836023811173959413420548e-4344 i": +Test "Imaginary part of: cexp (-10000 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Real part of: cexp (-2.0 - 3.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-720 + 0.75 i) == 1.486960657116368433685753325516638551722e-313 + 1.385247284245720590980701226843815229385e-313 i": +Test "Imaginary part of: cexp (-720 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (22730 + 0x1p-16434 i) == inf + 2.435706297811211974162115164702304105374e4924 i": +Test "Imaginary part of: cexp (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16494 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16494 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16494 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16494 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16494 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16494 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Real part of: clog (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i) == 11356.83823118610934184548269774874545400 + pi/4 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16494 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16494 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 3.2047474274603604594851472963586149973093e-29 + 1.4422922682185099608731642353544207976604 i": +Test "Imaginary part of: clog (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16494 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16494 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16494 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16494 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i) == -1.1931267660846218205882675852805793644095e-36 + 1.2402109774337032400594953899784058127412 i": +Test "Imaginary part of: clog (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2ede88p-23 + 0x771c3fp-23 i) == -4.4764192352906350039050902870893173560494e-13 + 1.1959106857549200806818600493552847793381 i": +Test "Imaginary part of: clog (0x2ede88p-23 + 0x771c3fp-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i) == -1.0509738482436128031927971874674370984602e-45 + 1.0509191467640012308402149909370784281448 i": +Test "Imaginary part of: clog (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i) == -5.2000108498455368032511404449795741611813e-32 + 1.5288921536982513453421343495466824420259 i": +Test "Imaginary part of: clog (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 8.3076914081087805757422664530653247447136e-30 + 1.2072712126771536614482822173033535043206 i": +Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x659feap-24 + 0xeaf6f9p-24 i) == 3.7303493627403868207597214252239749960738e-14 + 1.1625816408046866464773042283673653469061 i": +Test "Imaginary part of: clog (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6771f22c64ed551b857c128b4cp-105 + 0x1f570e7a13cc3cf2f44fd793ea1p-105 i) == -1.4281333889622737316199756373421183559948e-62 + 1.3673546561165378090903506783353927980633 i": +Test "Imaginary part of: clog (0x6771f22c64ed551b857c128b4cp-105 + 0x1f570e7a13cc3cf2f44fd793ea1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 2.4244570985709679851855191080208817099132e-37 + 1.1393074519572050614551047548718495655972 i": +Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i) == -9.7375017988218644730510244778042114638107e-30 + 0.9790637929494922564724108399524154766631 i": +Test "Real part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x9b57bp-20 + 0xcb7b4p-20 i) == -3.9563019528687610863490232935890272740908e-11 + 0.9187593477446338910857133065497364950682 i": +Test "Imaginary part of: clog (0x9b57bp-20 + 0xcb7b4p-20 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i) == 4.6017338806965821566734340588575402712716e-67 + 1.3547418904611758959096647942223384691728 i": +Test "Imaginary part of: clog (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i) == 6.6255694866654064502633121109394710807528e-66 + 1.0526409614996288387567810726095850312049 i": +Test "Imaginary part of: clog (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 5.3718272201930019901317065495843842735179e-26 + 1.0503831592447830576186444373011142397404 i": +Test "Imaginary part of: clog (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Real part of: clog10 (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Real part of: clog10 (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Imaginary part of: clog10 (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i) == 4.285899851347756186652871946325962330640e-19 + 4.611541215247321502041995872887317363241e-302 i": +Test "Real part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i) == 4.285899851347756186652871946325962330640e-19 + 4.611541215247321502041995872887317363241e-302 i": +Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-60 i) == 4.285899851347756188767674032946882584784e-19 + 4.285899850759344225805480528847018395861e-19 i": +Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-60 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Real part of: clog10 (0x1.234566p-50 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Real part of: clog10 (0x1.234566p-60 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 308.4052305577487344482591243175787477115 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i) == 4932.212175672014259683102930239951947672 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i) == 4932.112944269463028900262609694408579449 + 0.2069271710841128115912940666587802677383 i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1415bcaf2105940d49a636e98ae59p-115 + 0x7e6a150adfcd1b0921d44b31f40f4p-115 i) == 1.1288799405048268615023706955013387413519e-67 + 0.6137587762850841972073301550420510507903 i": +Test "Real part of: clog10 (0x1415bcaf2105940d49a636e98ae59p-115 + 0x7e6a150adfcd1b0921d44b31f40f4p-115 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i) == 4.4163015461643576961232672330852798804976e-31 + 0.3564851427422832755956993418877523303529 i": +Test "Imaginary part of: clog10 (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Real part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i) == -322.8546703496198318667349645920187712089 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i) == -4.5643214291682663316715446865040356750881e-46 + 0.4564083863660793840592614609053162690362 i": +Test "Imaginary part of: clog10 (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i) == 2.7822833698845776001753149807484078521508e-37 + 0.3992725998539071066769046272515417679815 i": +Test "Real part of: clog10 (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i) == -2.2583360179249556400630343805573865814771e-32 + 0.6639894257763289307423302343317622430835 i": +Test "Real part of: clog10 (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i) == -1.0146400362652473358437501879334790111898e-37 + 0.5149047982335273098246594109614460842099 i": +Test "Real part of: clog10 (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i) == 1.8804859395820231849002915747252695375405e-63 + 0.6404513901551516189871978418046651877394 i": +Test "Real part of: clog10 (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Real part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 1.0529283395205396881397407610630442563938e-37 + 0.4947949395762683446121140513971996916447 i": +Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i) == 1.9985076315737626043096596036300177494613e-67 + 0.5883569274304683249184005177865521205198 i": +Test "Real part of: clog10 (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i) == 2.8774482675253468630312378575186855052697e-66 + 0.4571561610046221605554903008571429975493 i": +Test "Imaginary part of: clog10 (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 @@ -1381,194 +1381,194 @@ ildouble: 1 ldouble: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 -Test "cos_downward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_downward (10)": ildouble: 1 ldouble: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_downward (6)": ildouble: 1 ldouble: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cos_towardzero -Test "cos_towardzero (10) == -0.8390715290764524522588639478240648345199": +Test "cos_towardzero (10)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (6) == 0.9601702866503660205456522979229244054519": +Test "cos_towardzero (6)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cos_upward -Test "cos_upward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_upward (1)": ildouble: 1 ldouble: 1 -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 -Test "cos_upward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_upward (4)": ildouble: 1 ldouble: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_tonearest -Test "cosh_tonearest (22) == 1792456423.065795780980053377632656584997": +Test "cosh_tonearest (22)": ildouble: 1 ldouble: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_upward -Test "cosh_upward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_upward (22)": ildouble: 1 ldouble: 1 -Test "cosh_upward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_upward (23)": ildouble: 1 ldouble: 1 -Test "cosh_upward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_upward (24)": ildouble: 1 ldouble: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 4 ldouble: 4 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 ildouble: 11 ldouble: 11 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 @@ -1577,907 +1577,905 @@ ildouble: 1 ldouble: 1 # csin -Test "Real part of: csin (-0.75 + 11357.25 i) == -8.385498349388321535962327491346664141020e4931 + 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (-0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 11357.25 i) == -8.385498349388321535962327491346664141020e4931 - 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (-0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-2 - 3 i) == -9.15449914691142957346729954460983256 + 4.16890695996656435075481305885375484 i": +Test "Imaginary part of: csin (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Real part of: csin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 11357.25 i) == 8.385498349388321535962327491346664141020e4931 + 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 11357.25 i) == 8.385498349388321535962327491346664141020e4931 - 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 -Test "Real part of: csin (0x1p-16434 + 22730 i) == 1.217853148905605987081057582351152052687e4924 + inf i": +Test "Real part of: csin (0x1p-16434 + 22730 i)": ildouble: 1 ldouble: 1 # csinh -Test "Imaginary part of: csinh (-11357.25 + 0.75 i) == -9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (-11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-11357.25 - 0.75 i) == -9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (-11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Real part of: csinh (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (22730 + 0x1p-16434 i) == inf + 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: csinh (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # csqrt -Test "Real part of: csqrt (-0x1.0000000000000000000000000001p-16382 - 0x1.0000000000000000000000000001p-16382 i) == 8.344545284118961663847948339519226074126e-2467 - 2.014551439675644900022606748976158925145e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000000000000000001p-16382 - 0x1.0000000000000000000000000001p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i) == 6.788430486774966350907249113759995429568e-155 - 1.638872094839911521020410942677082920935e-154 i": +Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0.75 + 1.25 i) == 1.05065169626078392338656675760808326 + 0.594868882070379067881984030639932657 i": +Test "Imaginary part of: csqrt (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i) == 2.014551439675644900022606748976158925145e-2466 + 8.344545284118961663847948339519226074126e-2": -ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i) == 2.014551439675644900022606748976158925145e-2466 + 8.344545284118961663847948339519226074126e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i) == 1.638872094839911521020410942677082920935e-154 + 6.788430486774966350907249113759995429568e-155 i": +Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Real part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1p+16383 i) == 1.106698967236475180613254276996359485630e+2466 + 2.687568007603946993388538156299100955642e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-16440 + 0x1p-16441 i) == 3.514690655930285351254618340783294558136e-2475 + 8.297059146828716918029689466551384219370e-2476 i": +Test "Imaginary part of: csqrt (0x1p-16440 + 0x1p-16441 i)": ildouble: 1 ldouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Real part of: ctan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Imaginary part of: ctan (0x1p1023 + 1 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Real part of: ctan (0x1p127 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Real part of: ctan (0x1p16383 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Imaginary part of: ctan (0x1p16383 + 1 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 355 i) == 8.140551093483276762350406321792653551513e-309 + 1.0 i": +Test "Real part of: ctan (1 + 355 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 365 i) == 1.677892637497921890115075995898773550884e-317 + 1.0 i": +Test "Real part of: ctan (1 + 365 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 45 i) == 1.490158918874345552942703234806348520895e-39 + 1.000000000000000000000000000000000000001 i": +Test "Real part of: ctan (1 + 45 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 47 i) == 2.729321264492904590777293425576722354636e-41 + 1.0 i": +Test "Real part of: ctan (1 + 47 i)": ildouble: 1 ldouble: 1 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 # ctan_tonearest -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 ifloat: 2 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 2 ifloat: 2 -Test "Real part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Real part of: ctanh (1 + 0x1p1023 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Imaginary part of: ctanh (1 + 0x1p127 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Real part of: ctanh (1 + 0x1p16383 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Imaginary part of: ctanh (1 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (355 + 1 i) == 1.0 + 8.140551093483276762350406321792653551513e-309 i": +Test "Imaginary part of: ctanh (355 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (365 + 1 i) == 1.0 + 1.677892637497921890115075995898773550884e-317 i": +Test "Imaginary part of: ctanh (365 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (45 + 1 i) == 1.000000000000000000000000000000000000001 + 1.490158918874345552942703234806348520895e-39 i": +Test "Imaginary part of: ctanh (45 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (47 + 1 i) == 1.0 + 2.729321264492904590777293425576722354636e-41 i": +Test "Imaginary part of: ctanh (47 + 1 i)": ildouble: 1 ldouble: 1 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 4 ldouble: 4 -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 2 ldouble: 2 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_upward -Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "erfc (0x1.ffffc8p+2) == 1.122671365033056305522366683719541099329e-29": +Test "erfc (0x1.ffffc8p+2)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (27.0) == 0.523704892378925568501606768284954709e-318": +Test "erfc (27.0)": ildouble: 1 ldouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 1 idouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 1 idouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 -Test "exp10 (4932) == 1.0e4932": +Test "exp10 (4932)": ildouble: 1 ldouble: 1 # exp2 -Test "exp2 (100.5) == 1.792728671193156477399422023278661496394e+30": +Test "exp2 (100.5)": ildouble: 1 ldouble: 1 # exp_downward -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_towardzero -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # expm1 -Test "expm1 (-79.0) == -0.9999999999999999999999999999999999509391": +Test "expm1 (-79.0)": ildouble: 1 ldouble: 1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # gamma -Test "gamma (-0.5) == log(2*sqrt(pi))": +Test "gamma (-0.5)": ildouble: 1 ldouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-0x1.001000001p+593) == -3.927269966354206207832593635798954916263e-90": +Test "j0 (-0x1.001000001p+593)": ildouble: 1 ldouble: 1 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # j1 -Test "j1 (-1.0) == -0.440050585744933515959682203718914913": +Test "j1 (-1.0)": ildouble: 1 ldouble: 1 -Test "j1 (0.75) == 0.349243602174862192523281016426251335": +Test "j1 (0.75)": ildouble: 1 ldouble: 1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (1.0) == 0.440050585744933515959682203718914913": +Test "j1 (1.0)": ildouble: 1 ldouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (1, -1.0) == -0.440050585744933515959682203718914913": +Test "jn (1, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (1, 0.75) == 0.349243602174862192523281016426251335": +Test "jn (1, 0.75)": ildouble: 1 ldouble: 1 -Test "jn (1, 1.0) == 0.440050585744933515959682203718914913": +Test "jn (1, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 2 ldouble: 2 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 5 ldouble: 5 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 ildouble: 3 ldouble: 3 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 ildouble: 8 ldouble: 8 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 @@ -2486,17 +2484,17 @@ ildouble: 3 ldouble: 3 # lgamma -Test "lgamma (-0.5) == log(2*sqrt(pi))": +Test "lgamma (-0.5)": ildouble: 1 ldouble: 1 -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -2505,422 +2503,422 @@ ildouble: 1 ldouble: 1 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # log2 -Test "log2 (0.75) == -.415037499278843818546261056052183492": +Test "log2 (0.75)": ildouble: 1 ldouble: 1 # pow -Test "pow (0x0.fffffffffffff8p0, -0x1.23456789abcdfp62) == 9.8826311568054561811190162420900667121992e+252": +Test "pow (0x0.fffffffffffff8p0, -0x1.23456789abcdfp62)": ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (10.0, -4930.0) == 1e-4930": +Test "pow (10.0, -4930.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4929.0) == 1e4929": +Test "pow (10.0, 4929.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4930.0) == 1e4930": +Test "pow (10.0, 4930.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4931.0) == 1e4931": +Test "pow (10.0, 4931.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4932.0) == 1e4932": +Test "pow (10.0, 4932.0)": ildouble: 1 ldouble: 1 -Test "pow (1e4932, 0.75) == 1e3699": +Test "pow (1e4932, 0.75)": ildouble: 1 ldouble: 1 # pow_downward -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 # pow_towardzero -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_downward -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 -Test "sin_downward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_downward (2)": ildouble: 1 ldouble: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_downward (4)": ildouble: 1 ldouble: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 -Test "sin_downward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_downward (8)": ildouble: 1 ldouble: 1 -Test "sin_downward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_downward (9)": ildouble: 1 ldouble: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 -Test "sin_tonearest (3) == 0.1411200080598672221007448028081102798469": +Test "sin_tonearest (3)": ildouble: 1 ldouble: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (2) == 0.9092974268256816953960198659117448427023": +Test "sin_towardzero (2)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (3) == 0.1411200080598672221007448028081102798469": +Test "sin_towardzero (3)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (8) == 0.9893582466233817778081235982452886721164": +Test "sin_towardzero (8)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_upward (10)": ildouble: 1 ldouble: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 -Test "sin_upward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_upward (3)": ildouble: 1 ldouble: 1 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 -Test "sin_upward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_upward (6)": ildouble: 1 ldouble: 1 -Test "sin_upward (7) == 0.6569865987187890903969990915936351779369": +Test "sin_upward (7)": ildouble: 1 ldouble: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 # sinh_upward -Test "sinh_upward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_upward (22)": ildouble: 1 ldouble: 1 -Test "sinh_upward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_upward (23)": ildouble: 1 ldouble: 1 -Test "sinh_upward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_upward (24)": ildouble: 1 ldouble: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_towardzero -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (6) == -0.2910061913847491570536995888681755428312": +Test "tan_towardzero (6)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": float: 1 ifloat: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_upward (2)": ildouble: 1 ldouble: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (4) == 1.1578212823495775831373424182673239231198": +Test "tan_upward (4)": ildouble: 1 ldouble: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_upward (6)": ildouble: 1 ldouble: 1 -Test "tan_upward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_upward (9)": ildouble: 1 ldouble: 1 # tanh -Test "tanh (-0.75) == -0.635148952387287319214434357312496495": +Test "tanh (-0.75)": ildouble: 1 ldouble: 1 -Test "tanh (-1.0) == -0.7615941559557648881194582826047935904": +Test "tanh (-1.0)": ildouble: 1 ldouble: 1 -Test "tanh (0.75) == 0.635148952387287319214434357312496495": +Test "tanh (0.75)": ildouble: 1 ldouble: 1 -Test "tanh (1.0) == 0.7615941559557648881194582826047935904": +Test "tanh (1.0)": ildouble: 1 ldouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (4) == 6": +Test "tgamma (4)": ildouble: 1 ldouble: 1 # y0 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-60) == -2.6550076313426878432849115782108205929120e+1": +Test "y0 (0x1p-60)": ildouble: 1 ldouble: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -2929,44 +2927,44 @@ ildouble: 3 ldouble: 3 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0.75) == -1.03759455076928541973767132140642198": +Test "y1 (0.75)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.001000001p+593) == 3.927269966354206207832593635798954916263e-90": +Test "y1 (0x1.001000001p+593)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y1 (0x1p-30) == -6.8356527557643159612937462812258975438856e+08": +Test "y1 (0x1p-30)": ildouble: 1 ldouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 @@ -2975,105 +2973,105 @@ ildouble: 1 ldouble: 1 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 0.75) == -1.03759455076928541973767132140642198": +Test "yn (1, 0.75)": ildouble: 1 ldouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 ildouble: 2 ldouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/ports/sysdeps/arm/Makefile b/libc/ports/sysdeps/arm/Makefile index 7c19398ff..232319d13 100644 --- a/libc/ports/sysdeps/arm/Makefile +++ b/libc/ports/sysdeps/arm/Makefile @@ -28,11 +28,6 @@ sysdep_routines += $(aeabi_constants) $(aeabi_routines) static-only-routines += $(aeabi_constants) endif -# to pull in __aeabi_read_tp, needed for tls -ifeq ($(subdir),malloc) -$(objpfx)libmemusage.so: $(common-objpfx)libc_nonshared.a -endif - ifeq ($(subdir),gmon) sysdep_routines += arm-mcount endif @@ -40,7 +35,3 @@ endif ifeq ($(subdir),debug) CFLAGS-backtrace.c += -funwind-tables endif - -ifeq ($(subdir),math) -$(objpfx)libm.so: $(elfobjdir)/ld.so -endif diff --git a/libc/ports/sysdeps/arm/dl-machine.h b/libc/ports/sysdeps/arm/dl-machine.h index 6e09aa107..4cf87a99f 100644 --- a/libc/ports/sysdeps/arm/dl-machine.h +++ b/libc/ports/sysdeps/arm/dl-machine.h @@ -398,8 +398,7 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc, strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); @@ -560,8 +559,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc, strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/ports/sysdeps/arm/libm-test-ulps b/libc/ports/sysdeps/arm/libm-test-ulps index e0c7e0d47..990a5bc82 100644 --- a/libc/ports/sysdeps/arm/libm-test-ulps +++ b/libc/ports/sysdeps/arm/libm-test-ulps @@ -1,1785 +1,1785 @@ # Begin of automatic generation # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 # asin_upward -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 # atan2 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # casinh -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 # cbrt -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 # cexp -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": float: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 ifloat: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cos_towardzero -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 # cos_upward -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 ifloat: 2 # csin -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # csinh -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctan_tonearest -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 ifloat: 2 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 2 ifloat: 2 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 idouble: 1 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 # ctanh_upward -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 1 idouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 1 idouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 # exp_downward -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 # exp_towardzero -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 # expm1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": float: 1 ifloat: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 ifloat: 2 # lgamma -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 ifloat: 2 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # pow -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 # pow_downward -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 # pow_towardzero -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 # sin_downward -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_towardzero -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": float: 1 ifloat: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": float: 1 ifloat: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # y0 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/ports/sysdeps/hppa/dl-machine.h b/libc/ports/sysdeps/hppa/dl-machine.h index a66be7ba4..d2411a654 100644 --- a/libc/ports/sysdeps/hppa/dl-machine.h +++ b/libc/ports/sysdeps/hppa/dl-machine.h @@ -673,8 +673,7 @@ elf_machine_rela (struct link_map *map, strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("%s: Symbol `%s' has different size in shared object, " "consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); @@ -730,7 +729,7 @@ elf_machine_rela_relative (Elf32_Addr l_addr, if (ELF32_R_SYM (reloc->r_info) != 0){ _dl_error_printf ("%s: In elf_machine_rela_relative " "ELF32_R_SYM (reloc->r_info) != 0. Aborting.", - rtld_progname ?: "<program name unknown>"); + RTLD_PROGNAME); ABORT_INSTRUCTION; /* Crash. */ } diff --git a/libc/ports/sysdeps/hppa/fpu/libm-test-ulps b/libc/ports/sysdeps/hppa/fpu/libm-test-ulps index f5469cf16..0b64644a2 100644 --- a/libc/ports/sysdeps/hppa/fpu/libm-test-ulps +++ b/libc/ports/sysdeps/hppa/fpu/libm-test-ulps @@ -1,3191 +1,3191 @@ # Begin of automatic generation # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 # asin_upward -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 # atan2 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (-0.25 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (-0.25 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-105 i) == 2.094395102393195492308428922186335256131 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-112 i) == 2.094395102393195492308428922186335256131 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i) == 2.094395102393190022547898764614298351924 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-105 i) == 2.094395102393195492308428922186335256131 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-112 i) == 2.094395102393195492308428922186335256131 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i) == 2.094395102393190022547898764614298351924 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 3.141592634635223399311902261000251614142 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 3.141592634635223399311902261000251614142 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i) == 3.141153467203602189751698864505105063797 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i) == 3.141153467203602189751698864505105063797 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (-0x1.000002p0 + 0x1p-23 i) == 3.141370441751352383825802745874586120521 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.000002p0 - 0x1p-23 i) == 3.141370441751352383825802745874586120521 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i) == 1.572134236154454360143880041170803681211 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i) == 1.572134236154454360143880041170803681211 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691640832196834 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-100 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691640832196834 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691640832196834 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-100 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691640832196834 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442101 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442101 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x0.ffffffp0 i) == 1.570796326794896619231321691639751442101 - 8.813735448726938863015878255140556727969e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 - 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1.fp-129 i) == 1.570796326794896619231321691639751442101 - 2.846900380897727558361783801085126250967e-39 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1p-23 i) == 1.570796326794896619231321691639751442101 - 1.192092895507809676556842485683592032154e-7 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442101 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442101 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1.fp-129 + 1.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442101 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442101 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x0.ffffffp0 i) == 1.570796326794896619231321691639751442101 + 8.813735448726938863015878255140556727969e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 + 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1.fp-129 i) == 1.570796326794896619231321691639751442101 + 2.846900380897727558361783801085126250967e-39 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1p-23 i) == 1.570796326794896619231321691639751442101 + 1.192092895507809676556842485683592032154e-7 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442101 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442101 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1.fp-129 - 1.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1.fp-30 + 1.0 i) == 1.570796328070826603447840231892468927106 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: cacos (-0x1.fp-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i) == 1.570796328070826603447840231892468927106 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-30 - 1.0 i) == 1.570796328070826603447840231892468927106 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: cacos (-0x1.fp-30 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i) == 1.570796328070826603447840231892468927106 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 + 0.0 i) == 1.570796326794896619231321691639776094002 - 0.0 i": +Test "Real part of: cacos (-0x1p-105 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 + 0.5 i) == 1.570796326794896619231321691639773491431 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i) == 1.570796326794896619231321691639773491431 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 + 0x1p-105 i) == 1.570796326794896619231321691639776094002 - 2.465190328815661891911651766508706967729e-32 i": +Test "Real part of: cacos (-0x1p-105 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 - 0.0 i) == 1.570796326794896619231321691639776094002 + 0.0 i": +Test "Real part of: cacos (-0x1p-105 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 - 0.5 i) == 1.570796326794896619231321691639773491431 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i) == 1.570796326794896619231321691639773491431 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 - 0x1p-105 i) == 1.570796326794896619231321691639776094002 + 2.465190328815661891911651766508706967729e-32 i": +Test "Real part of: cacos (-0x1p-105 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0.0 i) == 1.570796326794896619231321691639751634692 - 0.0 i": +Test "Real part of: cacos (-0x1p-112 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751614359 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751614359 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0x1p-112 i) == 1.570796326794896619231321691639751634692 - 1.925929944387235853055977942584927318538e-34 i": +Test "Real part of: cacos (-0x1p-112 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0.0 i) == 1.570796326794896619231321691639751634692 + 0.0 i": +Test "Real part of: cacos (-0x1p-112 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751614359 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751614359 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0x1p-112 i) == 1.570796326794896619231321691639751634692 + 1.925929944387235853055977942584927318538e-34 i": +Test "Real part of: cacos (-0x1p-112 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 + 0.0 i) == 1.570796446004186170012854035955502877351 - 0.0 i": +Test "Real part of: cacos (-0x1p-23 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 + 0.5 i) == 1.570796433418926613232299739606181733819 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: cacos (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i) == 1.570796433418926613232299739606181733819 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1p-23 + 0x1.fp-129 i) == 1.570796446004186170012854035955502877351 - 2.846900380897747786805634596726756660388e-39 i": +Test "Real part of: cacos (-0x1p-23 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 + 0x1p-23 i) == 1.570796446004186170012007003008248567984 - 1.192092895507818146886315028596704749235e-7 i": +Test "Real part of: cacos (-0x1p-23 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 - 0.0 i) == 1.570796446004186170012854035955502877351 + 0.0 i": +Test "Real part of: cacos (-0x1p-23 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 - 0.5 i) == 1.570796433418926613232299739606181733819 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: cacos (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i) == 1.570796433418926613232299739606181733819 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1p-23 - 0x1.fp-129 i) == 1.570796446004186170012854035955502877351 + 2.846900380897747786805634596726756660388e-39 i": +Test "Real part of: cacos (-0x1p-23 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 - 0x1p-23 i) == 1.570796446004186170012007003008248567984 + 1.192092895507818146886315028596704749235e-7 i": +Test "Real part of: cacos (-0x1p-23 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 + 0.0 i) == 1.570796326794896841275926616671059526825 - 0.0 i": +Test "Real part of: cacos (-0x1p-52 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 + 0.5 i) == 1.570796326794896817834053951421591208280 - 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: cacos (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i) == 1.570796326794896817834053951421591208280 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 + 0x1p-52 i) == 1.570796326794896841275926616671059526825 - 2.220446049250313080847263336181677117148e-16 i": +Test "Real part of: cacos (-0x1p-52 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 - 0.0 i) == 1.570796326794896841275926616671059526825 + 0.0 i": +Test "Real part of: cacos (-0x1p-52 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 - 0.5 i) == 1.570796326794896817834053951421591208280 + 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: cacos (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i) == 1.570796326794896817834053951421591208280 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 - 0x1p-52 i) == 1.570796326794896841275926616671059526825 + 2.220446049250313080847263336181677117148e-16 i": +Test "Real part of: cacos (-0x1p-52 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 + 0.0 i) == 1.570796326794896619339741908888301885499 - 0.0 i": +Test "Real part of: cacos (-0x1p-63 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 + 0.5 i) == 1.570796326794896619328295682000973043547 - 4.812118250596034474977589134243684231373e-1 i": +Test "Real part of: cacos (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i) == 1.570796326794896619328295682000973043547 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 + 0x1p-63 i) == 1.570796326794896619339741908888301885499 - 1.084202172485504434007452800869941711430e-19 i": +Test "Real part of: cacos (-0x1p-63 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 - 0.0 i) == 1.570796326794896619339741908888301885499 + 0.0 i": +Test "Real part of: cacos (-0x1p-63 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 - 0.5 i) == 1.570796326794896619328295682000973043547 + 4.812118250596034474977589134243684231373e-1 i": +Test "Real part of: cacos (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i) == 1.570796326794896619328295682000973043547 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 - 0x1p-63 i) == 1.570796326794896619339741908888301885499 + 1.084202172485504434007452800869941711430e-19 i": +Test "Real part of: cacos (-0x1p-63 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 + 0.5 i) == 2.466703808003786858297978415967328452322 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-1.0 + 0x1p50 i) == 1.570796326794897507409741391764983781004 - 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-1.0 + 0x1p50 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 - 0.5 i) == 2.466703808003786858297978415967328452322 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-1.0 - 0x1p50 i) == 1.570796326794897507409741391764983781004 + 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-1.0 - 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-2 - 3 i) == 2.1414491111159960199416055713254211 + 1.9833870299165354323470769028940395 i": +Test "Real part of: cacos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.25 + 1.0 i) == 1.394493894017929688812643125003661339452 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (0.25 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.25 - 1.0 i) == 1.394493894017929688812643125003661339452 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (0.25 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 - 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-105 i) == 1.047197551196597746154214461093167628066 - 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-105 i) == 1.047197551196597746154214461093167628066 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-112 i) == 1.047197551196597746154214461093167628066 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-112 i) == 1.047197551196597746154214461093167628066 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-23 i) == 1.047197551196603215914744618665204532273 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-52 i) == 1.047197551196597746154214461093186605110 - 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-63 i) == 1.047197551196597746154214461093167628070 - 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 + 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 1.0 i) == 1.221357263937683325603909865564381489366 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.5 + 1.0 i) == 1.221357263937683325603909865564381489366 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 + 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-105 i) == 1.047197551196597746154214461093167628066 + 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-105 i) == 1.047197551196597746154214461093167628066 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-112 i) == 1.047197551196597746154214461093167628066 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-112 i) == 1.047197551196597746154214461093167628066 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-23 i) == 1.047197551196603215914744618665204532273 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-52 i) == 1.047197551196597746154214461093186605110 + 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-63 i) == 1.047197551196597746154214461093167628070 + 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 - 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 1.0 i) == 1.221357263937683325603909865564381489366 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.5 - 1.0 i) == 1.221357263937683325603909865564381489366 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i) == 3.452669847162035876032494826387364972849e-4 - 0.0 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i) == 3.452669847162035876032494826387364972849e-4 - 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i) == 3.452669847162035876032494826387364972849e-4 + 0.0 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i) == 3.452669847162035876032494826387364972849e-4 + 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 - 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 + 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 - 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x1.000002p0 + 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 + 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x1.000002p0 - 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i) == 1.569458417435338878318763342108699202986 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i) == 1.569458417435338878318763342108699202986 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691638670687364 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691638670687364 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442096 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442097 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442097 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442096 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442097 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442097 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i) == 1.570796325518966635014803151387033957091 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i) == 1.570796325518966635014803151387033957091 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 - 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 - 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1p-105 + 0.5 i) == 1.570796326794896619231321691639729392766 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-105 - 0.5 i) == 1.570796326794896619231321691639729392766 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751269838 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751269838 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0.5 i) == 1.570796220170866625230343643673321150378 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0.5 i) == 1.570796220170866625230343643673321150378 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1p-52 + 0.5 i) == 1.570796326794896420628589431857911675917 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-52 - 0.5 i) == 1.570796326794896420628589431857911675917 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0.5 i) == 1.570796326794896619134347701278529840650 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0.5 i) == 1.570796326794896619134347701278529840650 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (1.0 + 0.25 i) == 4.890443302710802929202843732146540079124e-1 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: cacos (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 + 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (1.0 - 0.25 i) == 4.890443302710802929202843732146540079124e-1 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: cacos (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 - 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Real part of: cacosh (-0.25 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Real part of: cacosh (-0.25 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Imaginary part of: cacosh (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Imaginary part of: cacosh (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (-0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 3.141370441751352383825802745874586120521 i": +Test "Real part of: cacosh (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 3.141370441751352383825802745874586120521 i": +Test "Real part of: cacosh (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691640832196834 i": +Test "Imaginary part of: cacosh (-0x1.fp-100 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691640832196834 i": +Test "Imaginary part of: cacosh (-0x1.fp-100 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x0.ffffffp0 i) == 8.813735448726938863015878255140556727969e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.fp-129 i) == 2.846900380897727558361783801085126250967e-39 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442100 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x0.ffffffp0 i) == 8.813735448726938863015878255140556727969e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.fp-129 i) == 2.846900380897727558361783801085126250967e-39 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442100 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796328070826603447840231892468927106 i": +Test "Imaginary part of: cacosh (-0x1.fp-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796328070826603447840231892468927106 i": +Test "Imaginary part of: cacosh (-0x1.fp-30 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0.0 i) == 0.0 + 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639773491431 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0x1p-105 i) == 2.465190328815661891911651766508706967729e-32 + 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0.0 i) == 0.0 - 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639773491431 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0x1p-105 i) == 2.465190328815661891911651766508706967729e-32 - 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0.0 i) == 0.0 + 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751614359 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0x1p-112 i) == 1.925929944387235853055977942584927318538e-34 + 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0.0 i) == 0.0 - 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751614359 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0x1p-112 i) == 1.925929944387235853055977942584927318538e-34 - 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0.0 i) == 0.0 + 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796433418926613232299739606181733819 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0x1.fp-129 i) == 2.846900380897747786805634596726756660388e-39 + 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0x1p-23 i) == 1.192092895507818146886315028596704749235e-7 + 1.570796446004186170012007003008248567984 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0.0 i) == 0.0 - 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796433418926613232299739606181733819 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0x1.fp-129 i) == 2.846900380897747786805634596726756660388e-39 - 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0x1p-23 i) == 1.192092895507818146886315028596704749235e-7 - 1.570796446004186170012007003008248567984 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0.0 i) == 0.0 + 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896817834053951421591208280 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0x1p-52 i) == 2.220446049250313080847263336181677117148e-16 + 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0.0 i) == 0.0 - 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896817834053951421591208280 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0x1p-52 i) == 2.220446049250313080847263336181677117148e-16 - 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0.0 i) == 0.0 + 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619328295682000973043547 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0x1p-63 i) == 1.084202172485504434007452800869941711430e-19 + 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0.0 i) == 0.0 - 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619328295682000973043547 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0x1p-63 i) == 1.084202172485504434007452800869941711430e-19 - 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 3.098101355958774410750062883737683164607 i": +Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-1.0 + 0x1p50 i) == 3.535050620855721078027883819436759661753e1 + 1.570796326794897507409741391764983781004 i": +Test "Imaginary part of: cacosh (-1.0 + 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 3.098101355958774410750062883737683164607 i": +Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-1.0 - 0x1p50 i) == 3.535050620855721078027883819436759661753e1 - 1.570796326794897507409741391764983781004 i": +Test "Imaginary part of: cacosh (-1.0 - 0x1p50 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.394493894017929688812643125003661339452 i": +Test "Real part of: cacosh (0.25 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.394493894017929688812643125003661339452 i": +Test "Real part of: cacosh (0.25 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0.5 + +0 i) == +0 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 1.047197551196597746154214461093186605110 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 + 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.221357263937683325603909865564381489366 i": +Test "Imaginary part of: cacosh (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0.5 - 0 i) == +0 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 1.047197551196597746154214461093186605110 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 - 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.221357263937683325603909865564381489366 i": +Test "Imaginary part of: cacosh (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i) == 0.0 + 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 + 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i) == 0.0 - 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 - 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 2.222118384408546368406374049167636760903e-4 i": +Test "Real part of: cacosh (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 2.222118384408546368406374049167636760903e-4 i": +Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 2.222118384408546368406374049167636760903e-4 i": +Test "Real part of: cacosh (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 2.222118384408546368406374049167636760903e-4 i": +Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 + 0.25 i) == 5.097911466811016354623559941115413499164e-1 + 4.890443302710802929202843732146540079124e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Real part of: cacosh (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (1.0 - 0.25 i) == 5.097911466811016354623559941115413499164e-1 - 4.890443302710802929202843732146540079124e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Real part of: cacosh (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i)": float: 2 ifloat: 2 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.25 + 1.0 i) == -1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (-0.25 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0.25 - 1.0 i) == -1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (-0.25 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-105 i) == -5.235987755982988730771072305465838140329e-1 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 + 1.0 i) == -3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-105 i) == -5.235987755982988730771072305465838140329e-1 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 - 1.0 i) == -3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i) == -1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i) == -1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i) == -1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i) == -1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (-0x1.000002p0 + 0x1p-23 i) == -1.570574114956455764594481054234834678422 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.000002p0 - 0x1p-23 i) == -1.570574114956455764594481054234834678422 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (-0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (-0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i) == -1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i) == -1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i) == -1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i) == -1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i) == -3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i) == -2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i) == -3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i) == -2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i) == -2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i) == -2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i) == -1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i) == -2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i) == -2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i) == -1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-105 + 0.5 i) == -2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-105 - 0.5 i) == -2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-112 + 0.5 i) == -1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-112 - 0.5 i) == -1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-52 + 0.5 i) == -1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-52 - 0.5 i) == -1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0.5 i) == -9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0.5 i) == -9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-1.0 + 0.25 i) == -1.081751996523816326311037318425097434186 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (-1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-1.0 - 0.25 i) == -1.081751996523816326311037318425097434186 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (-1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0.25 + 1.0 i) == 1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (0.25 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0.25 - 1.0 i) == 1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (0.25 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-105 i) == 5.235987755982988730771072305465838140329e-1 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 + 1.0 i) == 3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-105 i) == 5.235987755982988730771072305465838140329e-1 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 - 1.0 i) == 3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i) == 1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i) == 1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (0x1.000002p0 + 0x1p-23 i) == 1.570574114956455764594481054234834678422 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.000002p0 - 0x1p-23 i) == 1.570574114956455764594481054234834678422 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i) == 1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i) == 1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i) == 1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i) == 1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i) == 3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i) == 2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i) == 3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i) == 2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i) == 2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i) == 2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i) == 1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i) == 2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i) == 2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i) == 1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 + 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 + 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1p-105 + 0.5 i) == 2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-105 - 0.5 i) == 2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-112 + 0.5 i) == 1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-112 - 0.5 i) == 1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-52 + 0.5 i) == 1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-52 - 0.5 i) == 1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-63 + 0.5 i) == 9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-63 - 0.5 i) == 9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (1.0 + 0.25 i) == 1.081751996523816326311037318425097434186 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casin (1.0 - 0.25 i) == 1.081751996523816326311037318425097434186 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 # casinh -Test "Imaginary part of: casinh (-0.25 + 1.0 i) == -5.097911466811016354623559941115413499164e-1 + 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (-0.25 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0.25 - 1.0 i) == -5.097911466811016354623559941115413499164e-1 - 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (-0.25 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.fp-10 + 1.0 i) == -4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (-0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.fp-10 - 1.0 i) == -4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (-0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.fp-129 + 0.5 i) == -3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1.fp-129 - 0.5 i) == -3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-105 + 0.5 i) == -2.846556599890768890940941645338546615370e-32 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-105 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-105 - 0.5 i) == -2.846556599890768890940941645338546615370e-32 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-105 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-112 + 0.5 i) == -2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-112 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-112 - 0.5 i) == -2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-112 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0.5 i) == -1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Real part of: casinh (-0x1p-23 + 0x1.000002p0 i) == -5.364668491573609633134147164031476452679e-4 + 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (-0x1p-23 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0x1p-23 - 0.5 i) == -1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Real part of: casinh (-0x1p-23 - 0x1.000002p0 i) == -5.364668491573609633134147164031476452679e-4 - 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (-0x1p-23 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0.25 i) == -8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (-1.0 + 0.25 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0.5 i) == -9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0.25 i) == -8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (-1.0 - 0.25 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0.5 i) == -9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 ildouble: 5 ldouble: 5 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 ildouble: 3 ldouble: 3 -Test "Imaginary part of: casinh (0.25 + 1.0 i) == 5.097911466811016354623559941115413499164e-1 + 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (0.25 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0.25 - 1.0 i) == 5.097911466811016354623559941115413499164e-1 - 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (0.25 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1.fp-10 + 1.0 i) == 4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0x1.fp-10 - 1.0 i) == 4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0x1.fp-129 + 0.5 i) == 3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp-129 - 0.5 i) == 3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-105 + 0.5 i) == 2.846556599890768890940941645338546615370e-32 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-105 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-105 - 0.5 i) == 2.846556599890768890940941645338546615370e-32 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-105 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-112 + 0.5 i) == 2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-112 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-112 - 0.5 i) == 2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-112 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-23 + 0.5 i) == 1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Real part of: casinh (0x1p-23 + 0x1.000002p0 i) == 5.364668491573609633134147164031476452679e-4 + 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (0x1p-23 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0x1p-23 - 0.5 i) == 1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Real part of: casinh (0x1p-23 - 0x1.000002p0 i) == 5.364668491573609633134147164031476452679e-4 - 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (0x1p-23 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0.25 i) == 8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (1.0 + 0.25 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0.5 i) == 9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0.25 i) == 8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (1.0 - 0.25 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0.5 i) == 9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 # catan -Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i) == -7.853981633974482679822974223765039144191e-1 + 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i) == -7.853981373204155542484315721351697277336e-1 + 6.103515973639646453881721999956617260502e-5 i": +Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1.0000000000001p0 - 0x1p-27 i) == -7.853981633974484345157511161499711112683e-1 - 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (-0x1.0000000000001p0 - 0x1p-27 i)": double: 1 idouble: 1 -Test "Real part of: catan (-0x1.000002p0 + 0x1p-126 i) == -7.853982230020895322927482174768220815493e-1 + 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (-0x1.000002p0 + 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000002p0 + 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 + 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000002p0 - 0x1p-126 i) == -7.853982230020895322927482174768220815493e-1 - 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (-0x1.000002p0 - 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000002p0 - 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i) == -1.570796326794896619231321691639751442099 + 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i) == -1.570796326794896619231321691639751442099 - 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i) == -1.570796326794896619231321691639751442097 + 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i) == -1.570796326794896619231321691639751442097 - 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i) == -7.853981633974483096156608458198757210493e-1 + 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i) == -7.853981633974483096156608458198757210493e-1 - 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: catan (-0x1p-13 + 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 + 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (-0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 + 1.0 i) == -7.854286809755354140031716771044626356262e-1 + 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (-0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 - 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-13 - 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Imaginary part of: catan (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 - 1.0 i) == -7.854286809755354140031716771044626356262e-1 - 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (-0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-54 + 1.0 i) == -7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (-0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-54 - 1.0 i) == -7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (-0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-57 + 1.0 i) == -7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (-0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-57 - 1.0 i) == -7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (-0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 + 0x1p-13 i) == -7.853981671227386080775748393881580082970e-1 + 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (-1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 - 0x1p-13 i) == -7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (-1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i) == 7.853981633974482679822974223765039144191e-1 + 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i) == 7.853981373204155542484315721351697277336e-1 + 6.103515973639646453881721999956617260502e-5 i": +Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1.0000000000001p0 - 0x1p-27 i) == 7.853981633974484345157511161499711112683e-1 - 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (0x1.0000000000001p0 - 0x1p-27 i)": double: 1 idouble: 1 -Test "Real part of: catan (0x1.000002p0 + 0x1p-126 i) == 7.853982230020895322927482174768220815493e-1 + 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (0x1.000002p0 + 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1.000002p0 + 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 + 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1.000002p0 - 0x1p-126 i) == 7.853982230020895322927482174768220815493e-1 - 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (0x1.000002p0 - 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1.000002p0 - 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i) == 1.570796326794896619231321691639751442099 + 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i) == 1.570796326794896619231321691639751442099 - 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i) == 1.570796326794896619231321691639751442097 + 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i) == 1.570796326794896619231321691639751442097 - 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1p-1020 + 1.0 i) == 7.853981633974483096156608458198757210493e-1 + 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (0x1p-1020 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1p-1020 - 1.0 i) == 7.853981633974483096156608458198757210493e-1 - 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (0x1p-1020 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: catan (0x1p-13 + 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 + 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 + 1.0 i) == 7.854286809755354140031716771044626356262e-1 + 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 - 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-13 - 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Imaginary part of: catan (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 - 1.0 i) == 7.854286809755354140031716771044626356262e-1 - 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-54 + 1.0 i) == 7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-54 - 1.0 i) == 7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-57 + 1.0 i) == 7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-57 - 1.0 i) == 7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 + 0x1p-13 i) == 7.853981671227386080775748393881580082970e-1 + 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 - 0x1p-13 i) == 7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (1.0 - 0x1p-13 i)": float: 1 ifloat: 1 # catanh -Test "Real part of: catanh (-0x1.000002p0 + 0x1p-13 i) == -4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Real part of: catanh (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1.000002p0 + 0x1p-13 i) == -4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1.000002p0 - 0x1p-13 i) == -4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Real part of: catanh (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1.000002p0 - 0x1p-13 i) == -4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i) == -2.871063043235098558826106732041811695767e-309 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i) == -2.871063043235098558826106732041811695767e-309 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i) == -1.516766904286822590927401983512575068153e-39 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i) == -1.516766904286822590927401983512575068153e-39 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-126 + 0x1.000002p0 i) == -5.877471053462247139383742414506671233336e-39 + 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (-0x1p-126 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-126 - 0x1.000002p0 i) == -5.877471053462247139383742414506671233336e-39 - 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (-0x1p-126 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-13 + 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-13 + 1.0 i) == -6.103515609841754902688560615027452023669e-5 + 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-13 - 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-13 - 1.0 i) == -6.103515609841754902688560615027452023669e-5 - 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-27 + 0x1.0000000000001p0 i) == -3.725290298461913200853528590596263270474e-9 + 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (-0x1p-27 + 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1p-27 - 0x1.0000000000001p0 i) == -3.725290298461913200853528590596263270474e-9 - 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (-0x1p-27 - 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-1.0 + 0x1p-1020 i) == -3.538516356758520804574969980043991380025e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-13 i) == -4.852030264850939738801379894163661227127 + 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 + 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 + 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-1020 i) == -3.538516356758520804574969980043991380025e2 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-13 i) == -4.852030264850939738801379894163661227127 - 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 ildouble: 4 ldouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1.000002p0 + 0x1p-13 i) == 4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1.000002p0 - 0x1p-13 i) == 4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i) == 2.871063043235098558826106732041811695767e-309 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i) == 2.871063043235098558826106732041811695767e-309 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i) == 1.516766904286822590927401983512575068153e-39 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i) == 1.516766904286822590927401983512575068153e-39 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (0x1p-126 + 0x1.000002p0 i) == 5.877471053462247139383742414506671233336e-39 + 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (0x1p-126 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-126 - 0x1.000002p0 i) == 5.877471053462247139383742414506671233336e-39 - 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (0x1p-126 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i) == 6.103515973639646453881721999956617260502e-5 + 7.853981373204155542484315721351697277336e-1 i": +Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 + 0x1.000002p0 i) == 6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 + 1.0 i) == 6.103515609841754902688560615027452023669e-5 + 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i) == 6.103515973639646453881721999956617260502e-5 - 7.853981373204155542484315721351697277336e-1 i": +Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 - 0x1.000002p0 i) == 6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 - 1.0 i) == 6.103515609841754902688560615027452023669e-5 - 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i) == 3.725290298461914441624447420137706700965e-9 + 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i) == 3.725290298461914441624447420137706700965e-9 - 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (1.0 + 0x1p-1020 i) == 3.538516356758520804574969980043991380025e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-13 i) == 4.852030264850939738801379894163661227127 + 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 + 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 + 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-1020 i) == 3.538516356758520804574969980043991380025e2 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-13 i) == 4.852030264850939738801379894163661227127 - 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-57 i)": float: 1 ifloat: 1 # cbrt -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 # cexp -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Real part of: clog (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Real part of: clog10 (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 308.4052305577487344482591243175787477115 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i) == -322.8546703496198318667349645920187712089 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 @@ -3194,118 +3194,118 @@ ildouble: 2 ldouble: 2 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cos_towardzero -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 # cos_upward -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 ildouble: 2 ldouble: 2 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 @@ -3314,564 +3314,564 @@ ildouble: 2 ldouble: 2 # csin -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # csinh -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctan_tonearest -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 ifloat: 2 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 2 ifloat: 2 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 idouble: 1 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 # ctanh_upward -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # erfc -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 -Test "exp10 (0.75) == 5.62341325190349080394951039776481231": +Test "exp10 (0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 6 float: 2 idouble: 6 ifloat: 2 ildouble: 6 ldouble: 6 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 # exp_downward -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 # exp_towardzero -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 # expm1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": float: 1 ifloat: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 4 ldouble: 4 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 3 ldouble: 3 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 ifloat: 2 # lgamma -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -3880,601 +3880,601 @@ ildouble: 1 ldouble: 1 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # pow -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 # pow_downward -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 # pow_towardzero -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 # sin_downward -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 +float: 1 idouble: 1 +ifloat: 1 ildouble: 1 ldouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 2": double: 1 -float: 1 idouble: 1 -ifloat: 1 ildouble: 1 ldouble: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_towardzero -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": float: 1 ifloat: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": float: 1 ifloat: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x0.fffffffffffff8p0) == -9.0071992547409924227843350984672961392521e+15": +Test "tgamma (-0x0.fffffffffffff8p0)": double: 1 idouble: 1 -Test "tgamma (-0x0.ffffffp0) == -1.6777216422784419250710305882992376932423e+07": +Test "tgamma (-0x0.ffffffp0)": float: 1 ifloat: 1 -Test "tgamma (-0x1.000002p0) == 8.3886075772158332060084424806449513922858e+06": +Test "tgamma (-0x1.000002p0)": double: 2 idouble: 2 -Test "tgamma (-0x1.0a32a2p+5) == 1.8125267978155035272941154746083439329912e-37": +Test "tgamma (-0x1.0a32a2p+5)": float: 2 ifloat: 2 -Test "tgamma (-0x13.ffffep0) == 2.1550026214525536756224040483579183652119e-13": +Test "tgamma (-0x13.ffffep0)": float: 2 ifloat: 2 -Test "tgamma (-0x14.000000000001p0) == -1.1569515572951781096476686854873801225397e-04": +Test "tgamma (-0x14.000000000001p0)": double: 1 idouble: 1 -Test "tgamma (-0x14.00002p0) == -2.1549777908265594916405421768142757507179e-13": +Test "tgamma (-0x14.00002p0)": float: 1 ifloat: 1 -Test "tgamma (-0x1d.ffffep0) == 1.9765721589464867957912772592816027583176e-27": +Test "tgamma (-0x1d.ffffep0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x1e.000000000001p0) == -1.0611571800204053929094168642022073530425e-18": +Test "tgamma (-0x1e.000000000001p0)": double: 3 idouble: 3 -Test "tgamma (-0x1e.00002p0) == -1.9765463890341964384070157599286498212650e-27": +Test "tgamma (-0x1e.00002p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x2.0000000000002p0) == -1.1258999068426235386078324507668462444260e+15": +Test "tgamma (-0x2.0000000000002p0)": double: 1 idouble: 1 -Test "tgamma (-0x2.000004p0) == -2.0971515386080557574407223895988378776747e+06": +Test "tgamma (-0x2.000004p0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (-0x2.fffffcp0) == -6.9905087601970247876992248591045142913324e+05": +Test "tgamma (-0x2.fffffcp0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x27.fffffffffffep0) == 1.7249032006742266376460389310340465554361e-34": +Test "tgamma (-0x27.fffffffffffep0)": double: 1 idouble: 1 -Test "tgamma (-0x28.000000000002p0) == -1.7249032006741359094184881234822934593822e-34": +Test "tgamma (-0x28.000000000002p0)": double: 1 idouble: 1 -Test "tgamma (-0x28.00004p0) == -3.2128372159115252365699015758097981155793e-43": +Test "tgamma (-0x28.00004p0)": double: 2 idouble: 2 -Test "tgamma (-0x29.00004p0) == 7.8361876024016854597745353972619195760515e-45": +Test "tgamma (-0x29.00004p0)": double: 1 idouble: 1 -Test "tgamma (-0x29.ffffcp0) == 1.8658121573125798145204120066590953505132e-46": +Test "tgamma (-0x29.ffffcp0)": double: 1 idouble: 1 -Test "tgamma (-0x3.000004p0) == 6.9905045731381300146131914617735687322025e+05": +Test "tgamma (-0x3.000004p0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (-0x3.fffffcp0) == 1.7476272942159602684441970627092458855771e+05": +Test "tgamma (-0x3.fffffcp0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x3.ffffffffffffep0) == 9.3824992236885396088236184658402406857503e+13": +Test "tgamma (-0x3.ffffffffffffep0)": double: 2 idouble: 2 -Test "tgamma (-0x31.fffffffffffep0) == 4.6273774273632946947805289899230181990085e-51": +Test "tgamma (-0x31.fffffffffffep0)": double: 3 idouble: 3 -Test "tgamma (-0x4.000008p0) == -8.7381270578483499672965708923121931082305e+04": +Test "tgamma (-0x4.000008p0)": float: 1 ifloat: 1 -Test "tgamma (-0x4.fffff8p0) == -1.7476280884325863043793087474680780379554e+04": +Test "tgamma (-0x4.fffff8p0)": double: 1 idouble: 1 -Test "tgamma (-0x4.ffffffffffffcp0) == -9.3824992236885475509805702650262155809819e+12": +Test "tgamma (-0x4.ffffffffffffcp0)": double: 1 idouble: 1 -Test "tgamma (-0x5.000008p0) == 1.7476252449031389167286893378510439443844e+04": +Test "tgamma (-0x5.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x5.ffffffffffffcp0) == 1.5637498706147581566449098589862357835505e+12": +Test "tgamma (-0x5.ffffffffffffcp0)": double: 1 idouble: 1 -Test "tgamma (-0x6.000008p0) == -2.9127085100239567622341538102130981196910e+03": +Test "tgamma (-0x6.000008p0)": float: 2 ifloat: 2 -Test "tgamma (-0x6.fffff8p0) == -4.1610198723079349791939054365613377035519e+02": +Test "tgamma (-0x6.fffff8p0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (-0x6.ffffffffffffcp0) == -2.2339283865925119357965832452642909859289e+11": +Test "tgamma (-0x6.ffffffffffffcp0)": double: 4 idouble: 4 -Test "tgamma (-0x63.fffffffffffcp0) == 7.5400833348840965463348754984345825364294e-145": +Test "tgamma (-0x63.fffffffffffcp0)": double: 2 idouble: 2 -Test "tgamma (-0x64.000000000004p0) == -7.5400833348831085791638490135462230991587e-145": +Test "tgamma (-0x64.000000000004p0)": double: 1 idouble: 1 -Test "tgamma (-0x7.0000000000004p0) == 2.2339283865925039372192897706214475877342e+11": +Test "tgamma (-0x7.0000000000004p0)": double: 3 idouble: 3 -Test "tgamma (-0x7.000008p0) == 4.1610118737306415004517215226199741948733e+02": +Test "tgamma (-0x7.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x7.fffff8p0) == 5.2012751504050764429534086402871289946986e+01": +Test "tgamma (-0x7.fffff8p0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "tgamma (-0x7.ffffffffffffcp0) == 2.7924104832406402297655703264222230055898e+10": +Test "tgamma (-0x7.ffffffffffffcp0)": double: 3 idouble: 3 -Test "tgamma (-0x8.00001p0) == -2.6006296115134418896533598545925084576702e+01": +Test "tgamma (-0x8.00001p0)": double: 2 idouble: 2 -Test "tgamma (-0x9.ffffffffffff8p0) == 1.5513391573559147700413058496716749249803e+08": +Test "tgamma (-0x9.ffffffffffff8p0)": double: 1 idouble: 1 -Test "tgamma (-0x9.fffffp0) == 2.8896008370721717567612135720915723136310e-01": +Test "tgamma (-0x9.fffffp0)": float: 1 ifloat: 1 -Test "tgamma (-0x96.000000000008p0) == -6.1582369322705655439003240743176243138734e-250": +Test "tgamma (-0x96.000000000008p0)": double: 1 idouble: 1 -Test "tgamma (-0xa.00001p0) == -2.8895878754728051776830454190076999107021e-01": +Test "tgamma (-0xa.00001p0)": double: 1 idouble: 1 -Test "tgamma (-2.5) == -9.4530872048294188122568932444861076415869e-01": +Test "tgamma (-2.5)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "tgamma (-3.5) == 2.7008820585226910892162552127103164690248e-01": +Test "tgamma (-3.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-4.5) == -6.0019601300504246427027893615784810422774e-02": +Test "tgamma (-4.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-5.5) == 1.0912654781909862986732344293779056440504e-02": +Test "tgamma (-5.5)": double: 1 idouble: 1 -Test "tgamma (-6.5) == -1.6788699664476712287280529682737009908468e-03": +Test "tgamma (-6.5)": float: 1 ifloat: 1 -Test "tgamma (-7.5) == 2.2384932885968949716374039576982679877958e-04": +Test "tgamma (-7.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (-8.5) == -2.6335215159963470254557693619979623385833e-05": +Test "tgamma (-8.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-9.5) == 2.7721279115751021320587045915768024616666e-06": +Test "tgamma (-9.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x1.fffffep0) == 9.9999994960018563231526611134590489120697e-01": +Test "tgamma (0x1.fffffep0)": float: 1 ifloat: 1 -Test "tgamma (0x1.fffffffffffffp0) == 9.9999999999999990612301934456883679778984e-01": +Test "tgamma (0x1.fffffffffffffp0)": double: 1 idouble: 1 -Test "tgamma (0x1p-24) == 1.6777215422784394050795179874582764575261e+07": +Test "tgamma (0x1p-24)": float: 1 ifloat: 1 -Test "tgamma (0x1p-53) == 9.0071992547409914227843350984672492007618e+15": +Test "tgamma (0x1p-53)": double: 1 idouble: 1 -Test "tgamma (0x2.30a43cp+4) == 3.4027979115654976101247558405326779640190e+38": +Test "tgamma (0x2.30a43cp+4)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "tgamma (0x2.fffffcp0) == 1.9999995599822108706107786027549565954046e+00": +Test "tgamma (0x2.fffffcp0)": float: 3 ifloat: 3 -Test "tgamma (0x3.fffffcp0) == 5.9999982031095793171233994481968816873643e+00": +Test "tgamma (0x3.fffffcp0)": float: 1 ifloat: 1 -Test "tgamma (0x3.ffffffffffffep0) == 5.9999999999999966530301828845138185025345e+00": +Test "tgamma (0x3.ffffffffffffep0)": double: 1 idouble: 1 -Test "tgamma (0x4.0000000000004p0) == 6.0000000000000066939396342309789716341613e+00": +Test "tgamma (0x4.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x4.ffffffffffffcp0) == 2.3999999999999967895170944875373910918544e+01": +Test "tgamma (0x4.ffffffffffffcp0)": double: 1 idouble: 1 -Test "tgamma (0x5.0000000000004p0) == 2.4000000000000032104829055124673225982803e+01": +Test "tgamma (0x5.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x5.000008p0) == 2.4000017236155647574166073485628713443799e+01": +Test "tgamma (0x5.000008p0)": float: 2 ifloat: 2 -Test "tgamma (0x5.fffff8p0) == 1.1999990237520611552119807476573441975106e+02": +Test "tgamma (0x5.fffff8p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0x6.0000000000004p0) == 1.2000000000000018184042734842640022086408e+02": +Test "tgamma (0x6.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x6.000008p0) == 1.2000009762487825358530770343720418162783e+02": +Test "tgamma (0x6.000008p0)": float: 2 ifloat: 2 -Test "tgamma (0x6.fffff8p0) == 7.1999935703082425988147448928288557689866e+02": +Test "tgamma (0x6.fffff8p0)": double: 1 idouble: 1 -Test "tgamma (0x6.ffffffffffffcp0) == 7.1999999999999880237602554542848858572672e+02": +Test "tgamma (0x6.ffffffffffffcp0)": double: 4 idouble: 4 -Test "tgamma (0x7.0000000000004p0) == 7.2000000000000119762397445457359071259652e+02": +Test "tgamma (0x7.0000000000004p0)": double: 4 idouble: 4 -Test "tgamma (0x7.000008p0) == 7.2000064296977505705636258629805621178587e+02": +Test "tgamma (0x7.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0x7.fffff8p0) == 5.0399951558933225045148935487583089307135e+03": +Test "tgamma (0x7.fffff8p0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (0x7.ffffffffffffcp0) == 5.0399999999999909771437166339103165198442e+03": +Test "tgamma (0x7.ffffffffffffcp0)": double: 2 idouble: 2 -Test "tgamma (0x8.00001p0) == 5.0400096882277802019946778420223050233915e+03": +Test "tgamma (0x8.00001p0)": double: 2 idouble: 2 -Test "tgamma (0xa.b9fd72b0fb238p+4) == 1.7976931348622298700886249281842651388250e+308": +Test "tgamma (0xa.b9fd72b0fb238p+4)": double: 1 idouble: 1 -Test "tgamma (10) == 362880": +Test "tgamma (10)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (18.5) == 1.4986120533153361177371791123515513270334e+15": +Test "tgamma (18.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (19.5) == 2.7724322986333718178137813578503699550119e+16": +Test "tgamma (19.5)": double: 2 idouble: 2 -Test "tgamma (2.5) == 1.3293403881791370204736256125058588870982e+00": +Test "tgamma (2.5)": float: 2 ifloat: 2 -Test "tgamma (23.5) == 5.3613035875444147334274983856108155717836e+21": +Test "tgamma (23.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (29.5) == 1.6348125198274266444378807806868221866931e+30": +Test "tgamma (29.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (3) == 2": +Test "tgamma (3)": float: 1 ifloat: 1 -Test "tgamma (3.5) == 3.3233509704478425511840640312646472177454e+00": +Test "tgamma (3.5)": float: 2 ifloat: 2 -Test "tgamma (30.5) == 4.8226969334909086010917483030261254507447e+31": +Test "tgamma (30.5)": float: 1 ifloat: 1 -Test "tgamma (33.5) == 1.5058569756267018925121415841930137587110e+36": +Test "tgamma (33.5)": float: 1 ifloat: 1 -Test "tgamma (34.5) == 5.0446208683494513399156743070465960916817e+37": +Test "tgamma (34.5)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "tgamma (4) == 6": +Test "tgamma (4)": float: 1 ifloat: 1 -Test "tgamma (4.5) == 1.1631728396567448929144224109426265262109e+01": +Test "tgamma (4.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (6) == 120": +Test "tgamma (6)": float: 1 ifloat: 1 -Test "tgamma (6.5) == 2.8788527781504436099631954670830006523720e+02": +Test "tgamma (6.5)": float: 1 ifloat: 1 -Test "tgamma (7) == 720": +Test "tgamma (7)": double: 1 idouble: 1 -Test "tgamma (7.5) == 1.8712543057977883464760770536039504240418e+03": +Test "tgamma (7.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (8) == 5040": +Test "tgamma (8)": double: 1 idouble: 1 -Test "tgamma (8.5) == 1.4034407293483412598570577902029628180313e+04": +Test "tgamma (8.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (9) == 40320": +Test "tgamma (9)": double: 1 idouble: 1 -Test "tgamma (9.5) == 1.1929246199460900708784991216725183953266e+05": +Test "tgamma (9.5)": double: 1 idouble: 1 # y0 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -4483,35 +4483,35 @@ ildouble: 1 ldouble: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 3 ldouble: 3 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 @@ -4520,108 +4520,108 @@ ildouble: 1 ldouble: 1 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 ildouble: 2 ldouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 ildouble: 1 diff --git a/libc/ports/sysdeps/ia64/fpu/libm-test-ulps b/libc/ports/sysdeps/ia64/fpu/libm-test-ulps index c5a2a0854..5036dd68c 100644 --- a/libc/ports/sysdeps/ia64/fpu/libm-test-ulps +++ b/libc/ports/sysdeps/ia64/fpu/libm-test-ulps @@ -1,237 +1,237 @@ # Begin of automatic generation # cacos -Test "Imaginary part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: cacos (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cacosh -Test "Real part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Real part of: cacosh (-2 - 3 i)": double: 1 float: 7 idouble: 1 ifloat: 7 ildouble: 7 ldouble: 7 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # casin -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: casin (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # casinh -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 ildouble: 5 ldouble: 5 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 ildouble: 5 ldouble: 5 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 # ccosh -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 # cexp -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 # clog -Test "Real part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Real part of: clog (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Real part of: clog10 (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos -Test "cos (0.80190127184058835) == 0.69534156199418473": +Test "cos (0.80190127184058835)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos (pi/2) == 0": +Test "cos (pi/2)": double: 1 float: 1 idouble: 1 @@ -240,50 +240,50 @@ ildouble: 1 ldouble: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 6 ldouble: 6 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 ildouble: 3 ldouble: 3 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 5 idouble: 1 ifloat: 5 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 ildouble: 4 ldouble: 4 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 3 idouble: 2 @@ -292,119 +292,119 @@ ildouble: 1 ldouble: 1 # csin -Test "Real part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Real part of: csin (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Imaginary part of: csin (0.75 + 1.25 i)": float: 1 ifloat: 1 # csinh -Test "Real part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Real part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Real part of: ctan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 24 ldouble: 24 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": float: 1 ifloat: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0.75) == 0.288844366346484868401062165408589223": +Test "erfc (0.75)": float: 1 ifloat: 1 -Test "erfc (1.25) == 0.0770998717435417698634765188027188596": +Test "erfc (1.25)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "exp10 (0.75) == 5.62341325190349080394951039776481231": +Test "exp10 (0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 6 float: 2 idouble: 6 @@ -413,172 +413,172 @@ ildouble: 3 ldouble: 3 # expm1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": ildouble: 1 ldouble: 1 # gamma -Test "gamma (-0.5) == log(2*sqrt(pi))": +Test "gamma (-0.5)": ildouble: 1 ldouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": float: 4 ifloat: 4 ildouble: 1 ldouble: 1 -Test "jn (3, -1.0) == -0.0195633539826684059189053216217515083": +Test "jn (3, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 idouble: 1 -Test "jn (3, 1.0) == 0.0195633539826684059189053216217515083": +Test "jn (3, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 2 idouble: 3 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": double: 1 float: 2 idouble: 1 @@ -587,15 +587,15 @@ ildouble: 1 ldouble: 1 # lgamma -Test "lgamma (-0.5) == log(2*sqrt(pi))": +Test "lgamma (-0.5)": ildouble: 1 ldouble: 1 -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -604,34 +604,34 @@ ildouble: 1 ldouble: 1 # log -Test "log (e) == 1": +Test "log (e)": float: 1 ifloat: 1 # log10 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sincos -Test "sincos (0.80190127184058835, &sin_res, &cos_res) puts 0.69534156199418473 in cos_res": +Test "sincos (0.80190127184058835) extra output 2": double: 1 idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +ildouble: 1 +ldouble: 1 +Test "sincos (M_PI_6l*2.0) extra output 2": double: 1 float: 1 idouble: 1 ifloat: 1 -ildouble: 1 -ldouble: 1 -Test "sincos (pi/2, &sin_res, &cos_res) puts 0 in cos_res": +Test "sincos (pi/2) extra output 2": double: 1 float: 1 idouble: 1 @@ -640,52 +640,52 @@ ildouble: 1 ldouble: 1 # tan -Test "tan (pi/4) == 1": +Test "tan (pi/4)": double: 1 idouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # y0 -Test "y0 (0.125) == -1.38968062514384052915582277745018693": +Test "y0 (0.125)": ildouble: 1 ldouble: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (2.0) == 0.510375672649745119596606592727157873": +Test "y0 (2.0)": double: 1 idouble: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -694,131 +694,131 @@ ildouble: 1 ldouble: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": -double: 3 -float: 1 -idouble: 3 -ifloat: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323"; +Test "y1 (1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (10.0)": +double: 3 +float: 1 +idouble: 3 +ifloat: 1 +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 # yn -Test "yn (0, 0.125) == -1.38968062514384052915582277745018693": +Test "yn (0, 0.125)": ildouble: 1 ldouble: 1 -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (0, 2.0) == 0.510375672649745119596606592727157873": +Test "yn (0, 2.0)": double: 1 idouble: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": -double: 3 +Test "yn (1, 1.5)": float: 1 -idouble: 3 ifloat: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323"; +ildouble: 1 +ldouble: 1 +Test "yn (1, 10.0)": +double: 3 float: 1 +idouble: 3 ifloat: 1 -ldouble: 1 -ildouble: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": float: 2 ifloat: 2 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/ports/sysdeps/m68k/coldfire/fpu/libm-test-ulps b/libc/ports/sysdeps/m68k/coldfire/fpu/libm-test-ulps index 8608c0d39..05be5a92b 100644 --- a/libc/ports/sysdeps/m68k/coldfire/fpu/libm-test-ulps +++ b/libc/ports/sysdeps/m68k/coldfire/fpu/libm-test-ulps @@ -1,594 +1,594 @@ # Begin of automatic generation # atan2 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacosh -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 # casin -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # casinh -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 # cbrt -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 # cexp -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 # clog -Test "Real part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Real part of: clog (0.75 + 1.25 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Real part of: clog10 (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": float: 1 ifloat: 1 # cos -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 ifloat: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 ifloat: 2 # csinh -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 # ctan -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 idouble: 1 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": float: 1 ifloat: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 idouble: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "exp10 (0.75) == 5.62341325190349080394951039776481231": +Test "exp10 (0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 6 float: 2 idouble: 6 ifloat: 2 # expm1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": float: 1 ifloat: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": float: 4 ifloat: 4 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 # lgamma -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 ifloat: 2 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # sincos -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # y0 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/ports/sysdeps/m68k/dl-machine.h b/libc/ports/sysdeps/m68k/dl-machine.h index b2ead16a0..acaabc1e1 100644 --- a/libc/ports/sysdeps/m68k/dl-machine.h +++ b/libc/ports/sysdeps/m68k/dl-machine.h @@ -238,8 +238,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc, strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/ports/sysdeps/m68k/m680x0/fpu/libm-test-ulps b/libc/ports/sysdeps/m68k/m680x0/fpu/libm-test-ulps index 9b339fd48..6af0bbd6f 100644 --- a/libc/ports/sysdeps/m68k/m680x0/fpu/libm-test-ulps +++ b/libc/ports/sysdeps/m68k/m680x0/fpu/libm-test-ulps @@ -1,4562 +1,4562 @@ # Begin of automatic generation # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # acos_upward -Test "acos_upward (-0) == pi/2": +Test "acos_upward (-0)": double: 1 idouble: 1 -Test "acos_upward (-0.5) == M_PI_6l*4.0": +Test "acos_upward (-0.5)": ildouble: 1 ldouble: 1 -Test "acos_upward (-1) == pi": +Test "acos_upward (-1)": double: 1 idouble: 1 -Test "acos_upward (0) == pi/2": +Test "acos_upward (0)": double: 1 idouble: 1 -Test "acos_upward (0.5) == M_PI_6l*2.0": +Test "acos_upward (0.5)": ildouble: 1 ldouble: 1 # acosh -Test "acosh (7) == 2.63391579384963341725009269461593689": +Test "acosh (7)": ildouble: 1 ldouble: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": ildouble: 1 ldouble: 1 -Test "asin_downward (-1.0) == -pi/2": +Test "asin_downward (-1.0)": double: 1 idouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # asin_upward -Test "asin_upward (-0.5) == -pi/6": +Test "asin_upward (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "asin_upward (0.5) == pi/6": +Test "asin_upward (0.5)": ildouble: 1 ldouble: 1 -Test "asin_upward (1.0) == pi/2": +Test "asin_upward (1.0)": double: 1 idouble: 1 # asinh -Test "asinh (0.75) == 0.693147180559945309417232121458176568": +Test "asinh (0.75)": ildouble: 1 ldouble: 1 # atan2 -Test "atan2 (0.390625, .00029) == 1.57005392693128974780151246612928941": +Test "atan2 (0.390625, .00029)": ildouble: 1 ldouble: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": ildouble: 1 ldouble: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": ildouble: 1 ldouble: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x0.fffffffffffff8p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x0.fffffffffffff8p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-1025 i) == 2.094395102393195492308428922186335256131 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-16385 i) == 2.094395102393195492308428922186335256131 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i) == 2.094395102393190022547898764614298351924 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-52 i) == 2.094395102393195492308428922186316279087 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (-0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-1025 i) == 2.094395102393195492308428922186335256131 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-16385 i) == 2.094395102393195492308428922186335256131 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i) == 2.094395102393190022547898764614298351924 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-52 i) == 2.094395102393195492308428922186316279087 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (-0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 3.141592634635223399311902261000251614142 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 3.141592634635223399311902261000251614142 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 3.141592653260520984471283759942320330996 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == 3.141592653170952461345846619605307690007 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 3.141592653260520984471283759942320330996 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == 3.141592653170952461345846619605307690007 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i) == 3.141153467203602189751698864505105063797 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i) == 3.141153467203602189751698864505105063797 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.0000000000000002p0 + 0x1p-63 i) == 3.141592653377875508152537040020250564229 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0x1.0000000000000002p0 - 0x1p-63 i) == 3.141592653377875508152537040020250564229 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0.0 i) == 3.141592653589793238462643383279502884197 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1p-52 i) == 3.141592643999491532482601997450598791535 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0.0 i) == 3.141592653589793238462643383279502884197 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1p-52 i) == 3.141592643999491532482601997450598791535 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i) == 1.572134236154454360143880041170803681211 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i) == 1.572134236154454360143880041170803681211 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691640832196834 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691640832196834 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442101 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442101 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442101 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442101 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i) == 1.570796328070826603447840231892468927106 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i) == 1.570796328070826603447840231892468927106 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i) == 1.570796326794896619231321691639773491431 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i) == 1.570796326794896619231321691639773491431 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751614359 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751614359 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i) == 1.570796433418926613232299739606181733819 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i) == 1.570796433418926613232299739606181733819 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i) == 1.570796326794896817834053951421591208280 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.570796326794896776240567560017266097201 - 8.813735870195429467279863907910458761820e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i) == 1.570796326794896817834053951421591208280 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.570796326794896776240567560017266097201 + 8.813735870195429467279863907910458761820e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i) == 1.570796326794896619328295682000973043547 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619307986362473920146173 - 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619307986362473920146173 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-63 + 0x1.0000000000000002p0 i) == 1.570796326794896619307986362473920146166 - 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: cacos (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i) == 1.570796326794896619328295682000973043547 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619307986362473920146173 + 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619307986362473920146173 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-63 - 0x1.0000000000000002p0 i) == 1.570796326794896619307986362473920146166 + 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: cacos (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 + 0.5 i) == 2.466703808003786858297978415967328452322 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 + 0.5 i) == 2.466703808003786858297978415967328452322 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 + 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 - 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (-1.0 + 0x1.fp-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-1.0 + 0x1.fp-100 i) == 3.141592653589792002170605123018614219682 - 1.236292038260260888664514866457202186027e-15 i": +Test "Real part of: cacos (-1.0 + 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1.fp-30 i) == 3.141550174918818561961484385371624132331 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 - 0.5 i) == 2.466703808003786858297978415967328452322 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 - 0.5 i) == 2.466703808003786858297978415967328452322 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 - 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 + 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (-1.0 - 0x1.fp-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-1.0 - 0x1.fp-100 i) == 3.141592653589792002170605123018614219682 + 1.236292038260260888664514866457202186027e-15 i": +Test "Real part of: cacos (-1.0 - 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1.fp-30 i) == 3.141550174918818561961484385371624132331 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + 0x1.fp-129 i) == 3.141592653589793238462643383279502884195 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + 0x1.fp-16385 i) == 3.141592653589793238462643383279502884197 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0 i) == pi + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0x1.fp-129 i) == 3.141592653589793238462643383279502884195 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0x1.fp-16385 i) == 3.141592653589793238462643383279502884197 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x0.fffffffffffff8p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x0.fffffffffffff8p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.25 + 1.0 i) == 1.394493894017929688812643125003661339452 - 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (0.25 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.25 - 1.0 i) == 1.394493894017929688812643125003661339452 + 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (0.25 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 - 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-16385 i) == 1.047197551196597746154214461093167628066 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Real part of: cacos (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-16385 i) == 1.047197551196597746154214461093167628066 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-105 i) == 1.047197551196597746154214461093167628066 - 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 + 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-112 i) == 1.047197551196597746154214461093167628066 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 + 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-23 i) == 1.047197551196603215914744618665204532273 - 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: cacos (0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-23 i) == 1.047197551196603215914744618665204532273 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-52 i) == 1.047197551196597746154214461093186605110 - 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-52 i) == 1.047197551196597746154214461093186605110 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-63 i) == 1.047197551196597746154214461093167628070 - 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 + 0x1p-63 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 + 1.0 i) == 1.221357263937683325603909865564381489366 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 + 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-16385 i) == 1.047197551196597746154214461093167628066 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Real part of: cacos (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-16385 i) == 1.047197551196597746154214461093167628066 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-105 i) == 1.047197551196597746154214461093167628066 + 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 - 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-112 i) == 1.047197551196597746154214461093167628066 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 - 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-23 i) == 1.047197551196603215914744618665204532273 + 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: cacos (0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-23 i) == 1.047197551196603215914744618665204532273 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-52 i) == 1.047197551196597746154214461093186605110 + 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-52 i) == 1.047197551196597746154214461093186605110 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-63 i) == 1.047197551196597746154214461093167628070 + 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 - 0x1p-63 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 - 1.0 i) == 1.221357263937683325603909865564381489366 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Real part of: cacos (0.75 + 1.25 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: cacos (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 - 1.171456840272878582596796205397918831268e-8 i": +Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 + 1.171456840272878582596796205397918831268e-8 i": +Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffp0 + 0.0 i) == 3.292722539913596233371825532007990724506e-10 - 0.0 i": +Test "Real part of: cacos (0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 3.292722539913596233371825532007990724506e-10 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Real part of: cacos (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 3.292722539913596233371825532007990724506e-10 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 - 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffp0 - 0.0 i) == 3.292722539913596233371825532007990724506e-10 + 0.0 i": +Test "Real part of: cacos (0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 3.292722539913596233371825532007990724506e-10 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Real part of: cacos (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 3.292722539913596233371825532007990724506e-10 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 + 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i) == 3.452669847162035876032494826387364972849e-4 - 0.0 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i) == 3.452669847162035876032494826387364972849e-4 - 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i) == 3.452669847162035876032494826387364972849e-4 + 0.0 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i) == 3.452669847162035876032494826387364972849e-4 + 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 - 5.116146586219826555037807251857670783420e-10 i": +Test "Real part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 + 5.116146586219826555037807251857670783420e-10 i": +Test "Real part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0.0 i) == 0.0 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1.fp-1025 i) == 2.557178503953494342609835913586108008322e-301 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 - 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0.0 i) == 0.0 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1.fp-1025 i) == 2.557178503953494342609835913586108008322e-301 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 + 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 - 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 + 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (0x1.fp-10 + 1.0 i) == 1.569458417435338878318763342108699202986 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: cacos (0x1.fp-10 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i) == 1.569458417435338878318763342108699202986 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.fp-10 - 1.0 i) == 1.569458417435338878318763342108699202986 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: cacos (0x1.fp-10 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i) == 1.569458417435338878318763342108699202986 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691638670687364 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691638670687364 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 0x0.fffffffffffff8p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 0x0.fffffffffffff8p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442096 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442097 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442097 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442097 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442096 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442097 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442097 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442097 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.fp-30 + 1.0 i) == 1.570796325518966635014803151387033957091 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: cacos (0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i) == 1.570796325518966635014803151387033957091 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.fp-30 - 1.0 i) == 1.570796325518966635014803151387033957091 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: cacos (0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i) == 1.570796325518966635014803151387033957091 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 - 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 - 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1p-105 + 0.5 i) == 1.570796326794896619231321691639729392766 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-105 - 0.5 i) == 1.570796326794896619231321691639729392766 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751269838 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751269838 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x1p-23 + 0.5 i) == 1.570796220170866625230343643673321150378 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: cacos (0x1p-23 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0.5 i) == 1.570796220170866625230343643673321150378 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-23 + 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 - 8.813735448726963984495965873956465777250e-1 i": +Test "Real part of: cacos (0x1p-23 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-23 - 0.5 i) == 1.570796220170866625230343643673321150378 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: cacos (0x1p-23 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0.5 i) == 1.570796220170866625230343643673321150378 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-23 - 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 + 8.813735448726963984495965873956465777250e-1 i": +Test "Real part of: cacos (0x1p-23 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 + 0.5 i) == 1.570796326794896420628589431857911675917 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.570796326794896462222075823262236786996 - 8.813735870195429467279863907910458761820e-1 i": +Test "Imaginary part of: cacos (0x1p-52 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 - 0.5 i) == 1.570796326794896420628589431857911675917 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.570796326794896462222075823262236786996 + 8.813735870195429467279863907910458761820e-1 i": +Test "Imaginary part of: cacos (0x1p-52 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0.5 i) == 1.570796326794896619134347701278529840650 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619154657020805582738025 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0.5 i) == 1.570796326794896619134347701278529840650 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619154657020805582738025 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0.25 i) == 4.890443302710802929202843732146540079124e-1 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: cacos (1.0 + 0.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 + 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 + 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0.25 i) == 4.890443302710802929202843732146540079124e-1 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: cacos (1.0 - 0.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 - 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 - 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + 0x1.fp-1025 i) == 4.819934639999230680322935210539402497827e-309 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + 0x1.fp-129 i) == 2.546345110742945032959687790021055102355e-39 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + 0x1.fp-16385 i) == 7.282957076134209141226696333885150260319e-4933 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0 i) == +0 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0x1.fp-1025 i) == 4.819934639999230680322935210539402497827e-309 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0x1.fp-129 i) == 2.546345110742945032959687790021055102355e-39 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0x1.fp-16385 i) == 7.282957076134209141226696333885150260319e-4933 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.0 + 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910371604180e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910371604180e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 2.094395102393195492308428922186316279087 i": +Test "Real part of: cacosh (-0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Imaginary part of: cacosh (-0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 2.094395102393195492308428922186316279087 i": +Test "Real part of: cacosh (-0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Imaginary part of: cacosh (-0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 + 3.141592653260520984471283759942320330996 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 3.141592653170952461345846619605307690007 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 - 3.141592653260520984471283759942320330996 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 3.141592653170952461345846619605307690007 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 3.141592653377875508152537040020250564229 i": +Test "Real part of: cacosh (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacosh (-0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 3.141592653377875508152537040020250564229 i": +Test "Real part of: cacosh (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacosh (-0x1.0000000000001p0 + 0.0 i) == 2.107342425544701550354780375182800088393e-8 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 3.141592643999491532482601997450598791535 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 - 0.0 i) == 2.107342425544701550354780375182800088393e-8 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 3.141592643999491532482601997450598791535 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910371604180e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910371604180e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-52 + 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910458761820e-1 + 1.570796326794896776240567560017266097201 i": +Test "Real part of: cacosh (-0x1p-52 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-52 - 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910458761820e-1 - 1.570796326794896776240567560017266097201 i": +Test "Real part of: cacosh (-0x1p-52 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 + 1.570796326794896619307986362473920146173 i": +Test "Real part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 + 1.570796326794896619307986362473920146173 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610131001e-1 + 1.570796326794896619307986362473920146166 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 - 1.570796326794896619307986362473920146173 i": +Test "Real part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 - 1.570796326794896619307986362473920146173 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610131001e-1 - 1.570796326794896619307986362473920146166 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 2.466703808003786858297978415967328452322 i": +Test "Imaginary part of: cacosh (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 3.098101355958774410750062883737683164607 i": +Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 3.098101355958774410750062883737683164607 i": +Test "Imaginary part of: cacosh (-1.0 + 0x1.fp-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 + 0x1.fp-100 i) == 1.236292038260260888664514866457202186027e-15 + 3.141592653589792002170605123018614219682 i": +Test "Imaginary part of: cacosh (-1.0 + 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 + 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 + 3.141550174918818561961484385371624132331 i": +Test "Real part of: cacosh (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 2.466703808003786858297978415967328452322 i": +Test "Imaginary part of: cacosh (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 3.098101355958774410750062883737683164607 i": +Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 3.098101355958774410750062883737683164607 i": +Test "Imaginary part of: cacosh (-1.0 - 0x1.fp-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 - 0x1.fp-100 i) == 1.236292038260260888664514866457202186027e-15 - 3.141592653589792002170605123018614219682 i": +Test "Imaginary part of: cacosh (-1.0 - 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 - 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 - 3.141550174918818561961484385371624132331 i": +Test "Real part of: cacosh (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 + 3.141592653589793238462643383279502884195 i": +Test "Real part of: cacosh (-1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 - 3.141592653589793238462643383279502884195 i": +Test "Real part of: cacosh (-1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Real part of: cacosh (-2 - 3 i)": double: 1 float: 7 idouble: 1 ifloat: 7 ildouble: 6 ldouble: 6 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cacosh (0.0 + 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910371604180e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910371604180e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.394493894017929688812643125003661339452 i": +Test "Imaginary part of: cacosh (0.25 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.394493894017929688812643125003661339452 i": +Test "Imaginary part of: cacosh (0.25 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + +0 i) == +0 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 1.047197551196603215914744618665204532273 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 1.047197551196597746154214461093186605110 i": +Test "Real part of: cacosh (0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 1.047197551196597746154214461093186605110 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 + 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0 i) == +0 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 1.047197551196603215914744618665204532273 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 1.047197551196597746154214461093186605110 i": +Test "Real part of: cacosh (0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 1.047197551196597746154214461093186605110 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 - 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.75 + 1.25 i) == 1.13239363160530819522266333696834467 + 1.11752014915610270578240049553777969 i": +Test "Real part of: cacosh (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.75 + 1.25 i) == 1.13239363160530819522266333696834467 + 1.11752014915610270578240049553777969 i": +Test "Imaginary part of: cacosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 1.895456983915074112227925127005564372844e-8 i": +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 1.895456983915074112227925127005564372844e-8 i": +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 + 0.0 i) == 0.0 + 3.292722539913596233371825532007990724506e-10 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 + 3.292722539913596233371825532007990724506e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 + 3.292722539913596233371825532007990724506e-10 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 4.188407771167967636741951941902992986043e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 4.188407771167967636741951941902992986043e-10 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 - 0.0 i) == 0.0 - 3.292722539913596233371825532007990724506e-10 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 - 3.292722539913596233371825532007990724506e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 - 3.292722539913596233371825532007990724506e-10 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 4.188407771167967636741951941902992986043e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 4.188407771167967636741951941902992986043e-10 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i) == 0.0 + 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 + 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i) == 0.0 - 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 - 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 2.119177303101063432592523199680782317447e-10 i": +Test "Real part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 2.119177303101063432592523199680782317447e-10 i": +Test "Imaginary part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 2.119177303101063432592523199680782317447e-10 i": +Test "Real part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 2.119177303101063432592523199680782317447e-10 i": +Test "Imaginary part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 + 0.0 i) == 2.107342425544701550354780375182800088393e-8 + 0.0 i": +Test "Real part of: cacosh (0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 + 2.557178503953494342609835913586108008322e-301 i": +Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 9.590301705980041385828904092662391018164e-9 i": +Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 - 0.0 i) == 2.107342425544701550354780375182800088393e-8 - 0.0 i": +Test "Real part of: cacosh (0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 - 2.557178503953494342609835913586108008322e-301 i": +Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 9.590301705980041385828904092662391018164e-9 i": +Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 2.222118384408546368406374049167636760903e-4 i": +Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 2.222118384408546368406374049167636760903e-4 i": +Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.569458417435338878318763342108699202986 i": +Test "Imaginary part of: cacosh (0x1.fp-10 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.569458417435338878318763342108699202986 i": +Test "Imaginary part of: cacosh (0x1.fp-10 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910371604180e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910371604180e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796325518966635014803151387033957091 i": +Test "Imaginary part of: cacosh (0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796325518966635014803151387033957091 i": +Test "Imaginary part of: cacosh (0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796220170866625230343643673321150378 i": +Test "Imaginary part of: cacosh (0x1p-23 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796242501197085295336701632142060969 i": +Test "Imaginary part of: cacosh (0x1p-23 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796220170866625230343643673321150378 i": +Test "Imaginary part of: cacosh (0x1p-23 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796242501197085295336701632142060969 i": +Test "Imaginary part of: cacosh (0x1p-23 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 + 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910458761820e-1 + 1.570796326794896462222075823262236786996 i": +Test "Real part of: cacosh (0x1p-52 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 - 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910458761820e-1 - 1.570796326794896462222075823262236786996 i": +Test "Real part of: cacosh (0x1p-52 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 + 1.570796326794896619154657020805582738025 i": +Test "Real part of: cacosh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 - 1.570796326794896619154657020805582738025 i": +Test "Real part of: cacosh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0.25 i) == 5.097911466811016354623559941115413499164e-1 + 4.890443302710802929202843732146540079124e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Real part of: cacosh (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (1.0 + 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 + 4.247867097467650115899790787875186617316e-5 i": +Test "Real part of: cacosh (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0.25 i) == 5.097911466811016354623559941115413499164e-1 - 4.890443302710802929202843732146540079124e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Real part of: cacosh (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (1.0 - 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 - 4.247867097467650115899790787875186617316e-5 i": +Test "Real part of: cacosh (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 + 4.819934639999230680322935210539402497827e-309 i": +Test "Real part of: cacosh (1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: cacosh (1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 + 7.282957076134209141226696333885150260319e-4933 i": +Test "Real part of: cacosh (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 - 4.819934639999230680322935210539402497827e-309 i": +Test "Real part of: cacosh (1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: cacosh (1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 - 7.282957076134209141226696333885150260319e-4933 i": +Test "Real part of: cacosh (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x0.fffffffffffff8p0 i) == -0.0 + 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffp0 i) == -0.0 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x1.000002p0 i) == -0.0 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x0.fffffffffffff8p0 i) == -0.0 - 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffp0 i) == -0.0 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x1.000002p0 i) == -0.0 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.25 + 1.0 i) == -1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: casin (-0.25 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.25 - 1.0 i) == -1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: casin (-0.25 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-1025 i) == -5.235987755982988730771072305465838140329e-1 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-16385 i) == -5.235987755982988730771072305465838140329e-1 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (-0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-52 i) == -5.235987755982988730771072305465648369889e-1 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0.5 + 1.0 i) == -3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (-0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 1.0 i) == -3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-1025 i) == -5.235987755982988730771072305465838140329e-1 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-16385 i) == -5.235987755982988730771072305465838140329e-1 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (-0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-52 i) == -5.235987755982988730771072305465648369889e-1 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0.5 - 1.0 i) == -3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (-0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 1.0 i) == -3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i) == -1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i) == -1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == -1.570796326465624365239962068302568888898 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -1.570796326376055842114524927965556247908 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == -1.570796326465624365239962068302568888898 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -1.570796326376055842114524927965556247908 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffp0 + 0.0 i) == -1.570451059810180415643718442157112705601 + 0.0 i": +Test "Real part of: casin (-0x0.ffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffp0 + 0x1.fp-129 i) == -1.570451059810180415643718442157112705601 + 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: casin (-0x0.ffffffp0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i) == -1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-0x0.ffffffp0 - 0.0 i) == -1.570451059810180415643718442157112705601 - 0.0 i": +Test "Real part of: casin (-0x0.ffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffp0 - 0x1.fp-129 i) == -1.570451059810180415643718442157112705601 - 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: casin (-0x0.ffffffp0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i) == -1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.0000000000000002p0 + 0x1p-63 i) == -1.570796326582978888921215348380499122131 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1.0000000000000002p0 - 0x1p-63 i) == -1.570796326582978888921215348380499122131 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0.0 i) == -1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1p-52 i) == -1.570796317204594913251280305810847349436 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0.0 i) == -1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1p-52 i) == -1.570796317204594913251280305810847349436 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (-0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (-0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-100 + 1.0 i) == -1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-100 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i) == -1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-100 - 1.0 i) == -1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-100 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i) == -1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-1000 + 1.0 i) == -1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-1000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i) == -1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1.fp-1000 - 1.0 i) == -1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-1000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i) == -1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1.fp-10000 + 1.0 i) == -6.867047849047171855399183659351043150871e-3011 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-10000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-10000 - 1.0 i) == -6.867047849047171855399183659351043150871e-3011 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i) == -3.810492908885321954658152505985270452320e-309 + 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-1025 + 1.0 i) == -3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-1025 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i) == -3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i) == -2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i) == -3.810492908885321954658152505985270452320e-309 - 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-1025 - 1.0 i) == -3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-1025 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i) == -3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i) == -2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i) == -2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-129 + 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-129 + 1.0 i) == -2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-129 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i) == -2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i) == -1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i) == -2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-129 - 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-129 - 1.0 i) == -2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-129 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i) == -2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i) == -1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == -5.757683115456107044287327268904964422212e-4933 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-16385 + 1.5 i) == -4.516698239814521372306784062043266700598e-4933 + 1.194763217287109304111930828519090523536 i": +Test "Real part of: casin (-0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == -5.757683115456107044287327268904964422212e-4933 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-16385 - 1.5 i) == -4.516698239814521372306784062043266700598e-4933 - 1.194763217287109304111930828519090523536 i": +Test "Real part of: casin (-0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (-0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (-0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-105 + 0.5 i) == -2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-105 - 0.5 i) == -2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-112 + 0.5 i) == -1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-112 - 0.5 i) == -1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-52 + 0.5 i) == -1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-52 + 0x0.fffffffffffff8p0 i) == -1.570092458683775146551022293016031474627e-16 + 8.813735870195429467279863907910458761820e-1 i": +Test "Imaginary part of: casin (-0x1p-52 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-52 + 0x1.0000000000001p0 i) == -1.570092458683774885078102529858632363236e-16 + 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (-0x1p-52 + 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1p-52 - 0.5 i) == -1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-52 - 0x0.fffffffffffff8p0 i) == -1.570092458683775146551022293016031474627e-16 - 8.813735870195429467279863907910458761820e-1 i": +Test "Imaginary part of: casin (-0x1p-52 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-52 - 0x1.0000000000001p0 i) == -1.570092458683774885078102529858632363236e-16 - 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (-0x1p-52 - 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0.5 i) == -9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i) == -7.666467083416870406778649849746878368519e-20 + 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0.5 i) == -9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i) == -7.666467083416870406778649849746878368519e-20 - 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 + 0.25 i) == -1.081751996523816326311037318425097434186 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (-1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-1.0 + 0x1.fp-129 i) == -1.570796326794896619177965338869929107115 + 5.335635276982233498398987585285818977933e-20 i": +Test "Real part of: casin (-1.0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1.fp-30 i) == -1.570753848123921942730162693731872690232 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 - 0.25 i) == -1.081751996523816326311037318425097434186 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (-1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-1.0 - 0x1.fp-129 i) == -1.570796326794896619177965338869929107115 - 5.335635276982233498398987585285818977933e-20 i": +Test "Real part of: casin (-1.0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1.fp-30 i) == -1.570753848123921942730162693731872690232 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + 0x1.fp-129 i) == -1.570796326794896619231321691639751442096 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + 0x1.fp-16385 i) == -1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0 i) == -pi/2 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0x1.fp-129 i) == -1.570796326794896619231321691639751442096 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0x1.fp-16385 i) == -1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x0.fffffffffffff8p0 i) == 0.0 + 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: casin (0.0 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffp0 i) == 0.0 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x1.000002p0 i) == 0.0 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x0.fffffffffffff8p0 i) == 0.0 - 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: casin (0.0 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffp0 i) == 0.0 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x1.000002p0 i) == 0.0 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.25 + 1.0 i) == 1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: casin (0.25 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.25 - 1.0 i) == 1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: casin (0.25 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-1025 i) == 5.235987755982988730771072305465838140329e-1 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-16385 i) == 5.235987755982988730771072305465838140329e-1 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-52 i) == 5.235987755982988730771072305465648369889e-1 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.5 + 1.0 i) == 3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 1.0 i) == 3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-1025 i) == 5.235987755982988730771072305465838140329e-1 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-16385 i) == 5.235987755982988730771072305465838140329e-1 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-52 i) == 5.235987755982988730771072305465648369889e-1 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.5 - 1.0 i) == 3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 1.0 i) == 3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 5 idouble: 1 ifloat: 5 ildouble: 3 ldouble: 3 -Test "Imaginary part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: casin (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 1.570796326465624365239962068302568888898 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 1.570796326376055842114524927965556247908 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 1.570796326465624365239962068302568888898 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 1.570796326376055842114524927965556247908 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffp0 + 0.0 i) == 1.570451059810180415643718442157112705601 + 0.0 i": +Test "Real part of: casin (0x0.ffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffp0 + 0x1.fp-129 i) == 1.570451059810180415643718442157112705601 + 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: casin (0x0.ffffffp0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i) == 1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0x0.ffffffp0 - 0.0 i) == 1.570451059810180415643718442157112705601 - 0.0 i": +Test "Real part of: casin (0x0.ffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffp0 - 0x1.fp-129 i) == 1.570451059810180415643718442157112705601 - 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: casin (0x0.ffffffp0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i) == 1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.0000000000000002p0 + 0x1p-63 i) == 1.570796326582978888921215348380499122131 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1.0000000000000002p0 - 0x1p-63 i) == 1.570796326582978888921215348380499122131 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1.0000000000001p0 + 0.0 i) == 1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1p-52 i) == 1.570796317204594913251280305810847349436 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 - 0.0 i) == 1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1p-52 i) == 1.570796317204594913251280305810847349436 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-100 + 1.0 i) == 1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-100 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i) == 1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-100 - 1.0 i) == 1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-100 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i) == 1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-1000 + 1.0 i) == 1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-1000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i) == 1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1.fp-1000 - 1.0 i) == 1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-1000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i) == 1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1.fp-10000 + 1.0 i) == 6.867047849047171855399183659351043150871e-3011 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-10000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-10000 - 1.0 i) == 6.867047849047171855399183659351043150871e-3011 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 0x0.fffffffffffff8p0 i) == 3.810492908885321954658152505985270452320e-309 + 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-1025 + 1.0 i) == 3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-1025 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i) == 3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i) == 2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 0x0.fffffffffffff8p0 i) == 3.810492908885321954658152505985270452320e-309 - 8.813735870195429467279863907910371604180e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-1025 - 1.0 i) == 3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-1025 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i) == 3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i) == 2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i) == 2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-129 + 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-129 + 1.0 i) == 2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-129 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i) == 2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i) == 1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i) == 2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-129 - 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-129 - 1.0 i) == 2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-129 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i) == 2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i) == 1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 5.757683115456107044287327268904964422212e-4933 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-16385 + 1.5 i) == 4.516698239814521372306784062043266700598e-4933 + 1.194763217287109304111930828519090523536 i": +Test "Real part of: casin (0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 5.757683115456107044287327268904964422212e-4933 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-16385 - 1.5 i) == 4.516698239814521372306784062043266700598e-4933 - 1.194763217287109304111930828519090523536 i": +Test "Real part of: casin (0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 + 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 + 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1p-105 + 0.5 i) == 2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-105 - 0.5 i) == 2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-112 + 0.5 i) == 1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-112 - 0.5 i) == 1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-52 + 0.5 i) == 1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.570092458683775146551022293016031474627e-16 + 8.813735870195429467279863907910458761820e-1 i": +Test "Imaginary part of: casin (0x1p-52 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-52 + 0x1.0000000000001p0 i) == 1.570092458683774885078102529858632363236e-16 + 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (0x1p-52 + 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1p-52 - 0.5 i) == 1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.570092458683775146551022293016031474627e-16 - 8.813735870195429467279863907910458761820e-1 i": +Test "Imaginary part of: casin (0x1p-52 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-52 - 0x1.0000000000001p0 i) == 1.570092458683774885078102529858632363236e-16 - 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (0x1p-52 - 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1p-63 + 0.5 i) == 9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 + 0x1.0000000000000002p0 i) == 7.666467083416870406778649849746878368519e-20 + 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 - 0.5 i) == 9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 - 0x1.0000000000000002p0 i) == 7.666467083416870406778649849746878368519e-20 - 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 + 0.25 i) == 1.081751996523816326311037318425097434186 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casin (1.0 + 0x1.fp-129 i) == 1.570796326794896619177965338869929107115 + 5.335635276982233498398987585285818977933e-20 i": +Test "Real part of: casin (1.0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1.fp-30 i) == 1.570753848123921942730162693731872690232 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 - 0.25 i) == 1.081751996523816326311037318425097434186 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casin (1.0 - 0x1.fp-129 i) == 1.570796326794896619177965338869929107115 - 5.335635276982233498398987585285818977933e-20 i": +Test "Real part of: casin (1.0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1.fp-30 i) == 1.570753848123921942730162693731872690232 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + 0x1.fp-129 i) == 1.570796326794896619231321691639751442096 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + 0x1.fp-16385 i) == 1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0 i) == pi/2 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0x1.fp-129 i) == 1.570796326794896619231321691639751442096 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0x1.fp-16385 i) == 1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # casinh -Test "Real part of: casinh (+0 + 1.5 i) == 0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (+0 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (+0 - 1.5 i) == 0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (+0 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.0 + 0x0.ffffffp0 i) == -0.0 + 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (-0.0 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.0 + 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.0 - 0x0.ffffffp0 i) == -0.0 - 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (-0.0 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.0 - 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.25 + 1.0 i) == -5.097911466811016354623559941115413499164e-1 + 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (-0.25 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0.25 - 1.0 i) == -5.097911466811016354623559941115413499164e-1 - 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (-0.25 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 + 0x1p-52 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 + 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 - 0x1p-52 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 - 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.fffffffffffff8p0 + 0.0 i) == -8.813735870195429467279863907910371604180e-1 + 0.0 i": +Test "Real part of: casinh (-0x0.fffffffffffff8p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.fffffffffffff8p0 + 0x1.fp-1025 i) == -8.813735870195429467279863907910371604180e-1 + 3.810492908885321954658152505985270452320e-309 i": +Test "Real part of: casinh (-0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.fffffffffffff8p0 + 0x1p-52 i) == -8.813735870195429467279863907910458761820e-1 + 1.570092458683775146551022293016031474627e-16 i": +Test "Real part of: casinh (-0x0.fffffffffffff8p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.fffffffffffff8p0 - 0.0 i) == -8.813735870195429467279863907910371604180e-1 - 0.0 i": +Test "Real part of: casinh (-0x0.fffffffffffff8p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.fffffffffffff8p0 - 0x1.fp-1025 i) == -8.813735870195429467279863907910371604180e-1 - 3.810492908885321954658152505985270452320e-309 i": +Test "Real part of: casinh (-0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.fffffffffffff8p0 - 0x1p-52 i) == -8.813735870195429467279863907910458761820e-1 - 1.570092458683775146551022293016031474627e-16 i": +Test "Real part of: casinh (-0x0.fffffffffffff8p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0.0 i) == -8.813735870195430251942769895627079569917e-1 + 0.0 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == -8.813735870195430251942769895627079569917e-1 + 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0.0 i) == -8.813735870195430251942769895627079569917e-1 - 0.0 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == -8.813735870195430251942769895627079569917e-1 - 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i) == -8.813735870195430253092739958139610131001e-1 + 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i) == -8.813735870195430253092739958139610131001e-1 - 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000001p0 + 0x1p-52 i) == -8.813735870195431822418551933572982483664e-1 + 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (-0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000001p0 - 0x1p-52 i) == -8.813735870195431822418551933572982483664e-1 - 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (-0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1.000002p0 + 0.0 i) == -8.813736713132375348727889167749389235161e-1 + 0.0 i": +Test "Real part of: casinh (-0x1.000002p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000002p0 + 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (-0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.000002p0 - 0.0 i) == -8.813736713132375348727889167749389235161e-1 - 0.0 i": +Test "Real part of: casinh (-0x1.000002p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000002p0 - 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (-0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.fp-10 + 1.0 i) == -4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (-0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.fp-10 - 1.0 i) == -4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (-0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.fp-1025 + 0.5 i) == -6.222508863508420569166420770843207333493e-309 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 + 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 + 1.5 i) == -9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 - 0.5 i) == -6.222508863508420569166420770843207333493e-309 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 - 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 - 1.5 i) == -9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 + 0.5 i) == -3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-129 + 0x0.ffffffp0 i) == -8.245504387859737323891843603996428534945e-36 + 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (-0x1.fp-129 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-129 + 1.0 i) == -5.335635276982233498398987585285818977933e-20 + 1.570796326794896619177965338869929107115 i": +Test "Imaginary part of: casinh (-0x1.fp-129 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 + 1.5 i) == -9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (-0x1.fp-129 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 - 0.5 i) == -3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-129 - 0x0.ffffffp0 i) == -8.245504387859737323891843603996428534945e-36 - 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (-0x1.fp-129 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-129 - 1.0 i) == -5.335635276982233498398987585285818977933e-20 - 1.570796326794896619177965338869929107115 i": +Test "Imaginary part of: casinh (-0x1.fp-129 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 - 1.5 i) == -9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (-0x1.fp-129 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 + 0.5 i) == -9.402257155670418112159334875199821342890e-4933 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == -2.472906068161537187835415298076415423459e-4923 + 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 + 1.5 i) == -9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 - 0.5 i) == -9.402257155670418112159334875199821342890e-4933 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == -2.472906068161537187835415298076415423459e-4923 - 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 - 1.5 i) == -9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-30 + 1.0 i) == -4.247867098745151888768727039216644758847e-5 + 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (-0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-30 - 1.0 i) == -4.247867098745151888768727039216644758847e-5 - 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (-0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0.5 i) == -1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1p-23 + 0.5 i) == -1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (-0x1p-23 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1p-23 - 0.5 i) == -1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1p-23 - 0.5 i) == -1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (-0x1p-23 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1p-52 + 0.5 i) == -2.563950248511418570403591756798643804971e-16 + 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (-0x1p-52 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0x1.0000000000001p0 i) == -2.315303644582684770975188768022139415020e-8 + 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (-0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0.5 i) == -2.563950248511418570403591756798643804971e-16 - 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (-0x1p-52 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0x1.0000000000001p0 i) == -2.315303644582684770975188768022139415020e-8 - 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (-0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -2.588578361325995866221775673638805081337e-10 + 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 + 0x1.0000000000000002p0 i) == -5.116146586219826555037807251857670783420e-10 + 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -2.588578361325995866221775673638805081337e-10 - 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 - 0x1.0000000000000002p0 i) == -5.116146586219826555037807251857670783420e-10 - 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casinh (-1.0 + 0.25 i) == -8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Imaginary part of: casinh (-1.0 + 0.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0.5 i) == -9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0.5 i) == -9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (-1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10000 i) == -8.813735870195430252326093249797923090282e-1 + 6.867047849047171855399183659351043150871e-3011 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casinh (-1.0 - 0.25 i) == -8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Imaginary part of: casinh (-1.0 - 0.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0.5 i) == -9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0.5 i) == -9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (-1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10000 i) == -8.813735870195430252326093249797923090282e-1 - 6.867047849047171855399183659351043150871e-3011 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.5 + 0x1.fp-16385 i) == -1.194763217287109304111930828519090523536 + 4.516698239814521372306784062043266700598e-4933 i": +Test "Imaginary part of: casinh (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.5 - 0x1.fp-16385 i) == -1.194763217287109304111930828519090523536 - 4.516698239814521372306784062043266700598e-4933 i": +Test "Imaginary part of: casinh (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 6 float: 19 idouble: 6 ifloat: 19 ildouble: 5 ldouble: 5 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 13 float: 6 idouble: 13 ifloat: 6 ildouble: 6 ldouble: 6 -Test "Imaginary part of: casinh (0.0 + 0x0.ffffffp0 i) == 0.0 + 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (0.0 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.0 + 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.0 - 0x0.ffffffp0 i) == 0.0 - 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (0.0 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.0 - 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.25 + 1.0 i) == 5.097911466811016354623559941115413499164e-1 + 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (0.25 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0.25 - 1.0 i) == 5.097911466811016354623559941115413499164e-1 - 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (0.25 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 + 0x1p-52 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 + 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 - 0x1p-52 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 - 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.fffffffffffff8p0 + 0.0 i) == 8.813735870195429467279863907910371604180e-1 + 0.0 i": +Test "Real part of: casinh (0x0.fffffffffffff8p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.fffffffffffff8p0 + 0x1.fp-1025 i) == 8.813735870195429467279863907910371604180e-1 + 3.810492908885321954658152505985270452320e-309 i": +Test "Real part of: casinh (0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.fffffffffffff8p0 + 0x1p-52 i) == 8.813735870195429467279863907910458761820e-1 + 1.570092458683775146551022293016031474627e-16 i": +Test "Real part of: casinh (0x0.fffffffffffff8p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.fffffffffffff8p0 - 0.0 i) == 8.813735870195429467279863907910371604180e-1 - 0.0 i": +Test "Real part of: casinh (0x0.fffffffffffff8p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.fffffffffffff8p0 - 0x1.fp-1025 i) == 8.813735870195429467279863907910371604180e-1 - 3.810492908885321954658152505985270452320e-309 i": +Test "Real part of: casinh (0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.fffffffffffff8p0 - 0x1p-52 i) == 8.813735870195429467279863907910458761820e-1 - 1.570092458683775146551022293016031474627e-16 i": +Test "Real part of: casinh (0x0.fffffffffffff8p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0.0 i) == 8.813735870195430251942769895627079569917e-1 + 0.0 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 8.813735870195430251942769895627079569917e-1 + 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0.0 i) == 8.813735870195430251942769895627079569917e-1 - 0.0 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 8.813735870195430251942769895627079569917e-1 - 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i) == 8.813735870195430253092739958139610131001e-1 + 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i) == 8.813735870195430253092739958139610131001e-1 - 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000001p0 + 0x1p-52 i) == 8.813735870195431822418551933572982483664e-1 + 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000001p0 - 0x1p-52 i) == 8.813735870195431822418551933572982483664e-1 - 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.000002p0 + 0.0 i) == 8.813736713132375348727889167749389235161e-1 + 0.0 i": +Test "Real part of: casinh (0x1.000002p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000002p0 + 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 + 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1.000002p0 - 0.0 i) == 8.813736713132375348727889167749389235161e-1 - 0.0 i": +Test "Real part of: casinh (0x1.000002p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000002p0 - 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 - 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1.fp-10 + 1.0 i) == 4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0x1.fp-10 - 1.0 i) == 4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0x1.fp-1025 + 0.5 i) == 6.222508863508420569166420770843207333493e-309 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 + 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 + 1.5 i) == 9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 - 0.5 i) == 6.222508863508420569166420770843207333493e-309 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 - 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 - 1.5 i) == 9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 + 0.5 i) == 3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-129 + 0x0.ffffffp0 i) == 8.245504387859737323891843603996428534945e-36 + 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (0x1.fp-129 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-129 + 1.0 i) == 5.335635276982233498398987585285818977933e-20 + 1.570796326794896619177965338869929107115 i": +Test "Imaginary part of: casinh (0x1.fp-129 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 + 1.5 i) == 9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (0x1.fp-129 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 - 0.5 i) == 3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-129 - 0x0.ffffffp0 i) == 8.245504387859737323891843603996428534945e-36 - 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (0x1.fp-129 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-129 - 1.0 i) == 5.335635276982233498398987585285818977933e-20 - 1.570796326794896619177965338869929107115 i": +Test "Imaginary part of: casinh (0x1.fp-129 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 - 1.5 i) == 9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (0x1.fp-129 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 + 0.5 i) == 9.402257155670418112159334875199821342890e-4933 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 2.472906068161537187835415298076415423459e-4923 + 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 + 1.5 i) == 9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 - 0.5 i) == 9.402257155670418112159334875199821342890e-4933 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 2.472906068161537187835415298076415423459e-4923 - 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 - 1.5 i) == 9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-30 + 1.0 i) == 4.247867098745151888768727039216644758847e-5 + 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-30 - 1.0 i) == 4.247867098745151888768727039216644758847e-5 - 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-23 + 0.5 i) == 1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1p-23 + 0.5 i) == 1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (0x1p-23 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1p-23 - 0.5 i) == 1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1p-23 - 0.5 i) == 1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (0x1p-23 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1p-52 + 0.5 i) == 2.563950248511418570403591756798643804971e-16 + 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (0x1p-52 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-52 + 0x1.0000000000001p0 i) == 2.315303644582684770975188768022139415020e-8 + 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 - 0.5 i) == 2.563950248511418570403591756798643804971e-16 - 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (0x1p-52 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-52 - 0x1.0000000000001p0 i) == 2.315303644582684770975188768022139415020e-8 - 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 2.588578361325995866221775673638805081337e-10 + 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 + 0x1.0000000000000002p0 i) == 5.116146586219826555037807251857670783420e-10 + 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 2.588578361325995866221775673638805081337e-10 - 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 - 0x1.0000000000000002p0 i) == 5.116146586219826555037807251857670783420e-10 - 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 + 0.25 i) == 8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Imaginary part of: casinh (1.0 + 0.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0.5 i) == 9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0.5 i) == 9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-10000 i) == 8.813735870195430252326093249797923090282e-1 + 6.867047849047171855399183659351043150871e-3011 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 - 0.25 i) == 8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Imaginary part of: casinh (1.0 - 0.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0.5 i) == 9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0.5 i) == 9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-10000 i) == 8.813735870195430252326093249797923090282e-1 - 6.867047849047171855399183659351043150871e-3011 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.5 + 0x1.fp-16385 i) == 1.194763217287109304111930828519090523536 + 4.516698239814521372306784062043266700598e-4933 i": +Test "Imaginary part of: casinh (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.5 - 0x1.fp-16385 i) == 1.194763217287109304111930828519090523536 - 4.516698239814521372306784062043266700598e-4933 i": +Test "Imaginary part of: casinh (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: catan (0.75 + 1.25 i) == 1.10714871779409050301706546017853704 + 0.549306144334054845697622618461262852 i": +Test "Real part of: catan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cbrt -Test "cbrt (-0.001) == -0.1": +Test "cbrt (-0.001)": ildouble: 1 ldouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": ildouble: 1 ldouble: 1 # ccos -Test "Real part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Real part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cexp -Test "Real part of: cexp (-10000 + 0x1p16383 i) == 1.045876464564882298442774542991176546722e-4343 + 4.421154026488516836023811173959413420548e-4344 i": +Test "Real part of: cexp (-10000 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Real part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Real part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Real part of: cexp (-95 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (11356.5625 + 0.75 i) == 9.052188470850960144814815984311663764287e4931 + 8.432986734191301036267148978260970230200e4931 i": +Test "Imaginary part of: cexp (11356.5625 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": ildouble: 1 ldouble: 1 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Real part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Real part of: clog (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Imaginary part of: clog (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i) == -5.421010862427522170184200798202494495630e-20 + 3.548665303440282824232502561095699343814e-4516 i": +Test "Real part of: clog (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-100 i) == 8.237022655933121125560939513260027133767e-5 + 8.974094312218060110948251664314290484113e-31 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p+16383 i) == 11356.60974243783798653123798337822335902 + 0.4764674194737066993385333770295162295856 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x1.fp+16383 + 0x1p+16383 i) == 11356.60974243783798653123798337822335902 + 0.4764674194737066993385333770295162295856 i": +Test "Imaginary part of: clog (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x11682p-23 + 0x7ffed1p-23 i) == 1.1723955140027907954461000991619077811832e-12 + 1.5622968405332756349813737986164832897108 i": +Test "Imaginary part of: clog (0x11682p-23 + 0x7ffed1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 4.4469229730850767799109418892826021157328e-20 + 1.2046235979300843056806465045930070146351 i": +Test "Imaginary part of: clog (0x2dd46725bp-35 + 0x7783a1284p-35 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 8.3076914081087805757422664530653247447136e-30 + 1.2072712126771536614482822173033535043206 i": +Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i) == -2.3362950222592964220878638677292132852104e-37 + 1.1856121127236268105413184264288408265852 i": +Test "Imaginary part of: clog (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 2.4244570985709679851855191080208817099132e-37 + 1.1393074519572050614551047548718495655972 i": +Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i) == -9.7375017988218644730510244778042114638107e-30 + 0.9790637929494922564724108399524154766631 i": +Test "Imaginary part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xa1f2c1p-24 + 0xc643aep-24 i) == -1.0480505352462576151523512837107080269981e-13 + 0.8858771987699967480545613322309315260313 i": +Test "Imaginary part of: clog (0xa1f2c1p-24 + 0xc643aep-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xa4722f19346cp-51 + 0x7f9631c5e7f07p-51 i) == -6.2122796286154679676173624516405339768606e-30 + 1.4904138780720095276446375492434049214172 i": +Test "Imaginary part of: clog (0xa4722f19346cp-51 + 0x7f9631c5e7f07p-51 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.234566p-40 - 1.0 i) == 2.325249110681915353442924915876654139373e-25 - 6.821881769213700828789403802671540158935e-1 i": +Test "Imaginary part of: clog10 (-0x1.234566p-40 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Real part of: clog10 (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Real part of: clog10 (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Imaginary part of: clog10 (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i) == -2.354315103889861110220423157644627849164e-20 + 1.541165759405643564697852372112893034397e-4516 i": +Test "Real part of: clog10 (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Real part of: clog10 (0x1.234566p-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Real part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-16440 + 0x1p-16441 i) == -4948.884673709346821106688037612752099609 + 0.2013595981366865710389502301937289472543 i": +Test "Imaginary part of: clog10 (0x1p-16440 + 0x1p-16441 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Imaginary part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x659b70ab7971bp-53 + 0x1f5d111e08abecp-53 i) == -1.0893543813872082317104059174982092534059e-30 + 0.5954257879188711495921161433751775633232 i": +Test "Imaginary part of: clog10 (0x659b70ab7971bp-53 + 0x1f5d111e08abecp-53 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 1.0529283395205396881397407610630442563938e-37 + 0.4947949395762683446121140513971996916447 i": +Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x81b7efa81fc35ad1p-65 + 0x1ef4b835f1c79d812p-65 i) == -4.3074341162203896332989394770760901408798e-39 + 0.5709443672155660428417571212549720987784 i": +Test "Imaginary part of: clog10 (0x81b7efa81fc35ad1p-65 + 0x1ef4b835f1c79d812p-65 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i) == -4.2289432987513243393180377141513840878196e-30 + 0.4252020027092323591068799049905597805296 i": +Test "Real part of: clog10 (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i) == -4.2289432987513243393180377141513840878196e-30 + 0.4252020027092323591068799049905597805296 i": +Test "Imaginary part of: clog10 (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0xa1f2c1p-24 + 0xc643aep-24 i) == -4.5516256421319921959681423447271490869664e-14 + 0.3847315790697197749315054516562206543710 i": +Test "Imaginary part of: clog10 (0xa1f2c1p-24 + 0xc643aep-24 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0xa4722f19346cp-51 + 0x7f9631c5e7f07p-51 i) == -2.6979587627476803379953050733225113494503e-30 + 0.6472785229986997177606324374555347813105 i": +Test "Imaginary part of: clog10 (0xa4722f19346cp-51 + 0x7f9631c5e7f07p-51 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": float: 1 ifloat: 1 # cos -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos (pi/2) == 0": +Test "cos (pi/2)": double: 1 float: 1 idouble: 1 @@ -4565,36 +4565,36 @@ ildouble: 1 ldouble: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_downward (10)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": double: 1 idouble: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": ildouble: 1 ldouble: 1 -Test "cos_downward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_downward (9)": double: 1 float: 1 idouble: 1 @@ -4603,194 +4603,194 @@ ildouble: 1 ldouble: 1 # cos_towardzero -Test "cos_towardzero (1) == 0.5403023058681397174009366074429766037323": +Test "cos_towardzero (1)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (10) == -0.8390715290764524522588639478240648345199": +Test "cos_towardzero (10)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (4) == -0.6536436208636119146391681830977503814241": +Test "cos_towardzero (4)": double: 1 idouble: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos_upward -Test "cos_upward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_upward (1)": float: 1 ifloat: 1 -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": ildouble: 1 ldouble: 1 -Test "cos_upward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_upward (2)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_upward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_upward (4)": double: 1 idouble: 1 -Test "cos_upward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_upward (5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": double: 1 idouble: 1 -Test "cos_upward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_upward (8)": double: 1 float: 1 idouble: 1 ifloat: 1 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_upward -Test "cosh_upward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_upward (22)": ildouble: 1 ldouble: 1 -Test "cosh_upward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_upward (24)": double: 1 idouble: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": float: 3 ifloat: 3 ildouble: 9 ldouble: 9 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 1 float: 3 idouble: 1 ifloat: 3 ildouble: 15 ldouble: 15 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 5 ldouble: 5 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 6 ifloat: 6 ildouble: 2 ldouble: 2 -Test "Real part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Real part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": float: 1 ifloat: 1 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 3 idouble: 2 @@ -4799,393 +4799,393 @@ ildouble: 1 ldouble: 1 # csin -Test "Real part of: csin (-2 - 3 i) == -9.15449914691142957346729954460983256 + 4.16890695996656435075481305885375484 i": +Test "Real part of: csin (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csin (-2 - 3 i) == -9.15449914691142957346729954460983256 + 4.16890695996656435075481305885375484 i": +Test "Imaginary part of: csin (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Real part of: csin (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Imaginary part of: csin (0.75 + 1.25 i)": float: 1 ifloat: 1 # csinh -Test "Real part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Real part of: csinh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i) == 6.788430486774966350907249113759995429568e-155 - 1.638872094839911521020410942677082920935e-154 i": +Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i) == 1.638872094839911521020410942677082920935e-154 + 6.788430486774966350907249113759995429568e-155 i": +Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-1073 + 0x1p-1073 i) == 3.453664695497464982856905711457966660085e-162 + 1.430554756764195530630723976279903095110e-162 i": +Test "Imaginary part of: csqrt (0x1p-1073 + 0x1p-1073 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-1074 + 0x1p-1074 i) == 2.442109726130830256743814843868934877597e-162 + 1.011554969366634726113090867589031782487e-162 i": +Test "Imaginary part of: csqrt (0x1p-1074 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-147 + 0x1p-147 i) == 8.225610928685557596194006925540350401606e-23 + 3.407159605465907500737319471202779419102e-23 i": +Test "Imaginary part of: csqrt (0x1p-147 + 0x1p-147 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-149 + 0x1p-149 i) == 4.112805464342778798097003462770175200803e-23 + 1.703579802732953750368659735601389709551e-23 i": +Test "Imaginary part of: csqrt (0x1p-149 + 0x1p-149 i)": ildouble: 1 ldouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Real part of: ctan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Real part of: ctan (0x1p127 + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Imaginary part of: ctan (0x1p16383 + 1 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 -Test "Real part of: ctan (1 + 45 i) == 1.490158918874345552942703234806348520895e-39 + 1.000000000000000000000000000000000000001 i": +Test "Real part of: ctan (1 + 45 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 47 i) == 2.729321264492904590777293425576722354636e-41 + 1.0 i": +Test "Real part of: ctan (1 + 47 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 5680 i) == 4.725214596136812019616700920476949798307e-4934 + 1.0 i": +Test "Real part of: ctan (1 + 5680 i)": ildouble: 1 ldouble: 1 # ctan_downward -Test "Imaginary part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 3 float: 1 idouble: 3 ifloat: 1 # ctan_tonearest -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 4 ldouble: 4 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 idouble: 1 ildouble: 8 ldouble: 8 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Imaginary part of: ctanh (1 + 0x1p127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Real part of: ctanh (1 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (45 + 1 i) == 1.000000000000000000000000000000000000001 + 1.490158918874345552942703234806348520895e-39 i": +Test "Imaginary part of: ctanh (45 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (47 + 1 i) == 1.0 + 2.729321264492904590777293425576722354636e-41 i": +Test "Imaginary part of: ctanh (47 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (5680 + 1 i) == 1.0 + 4.725214596136812019616700920476949798307e-4934 i": +Test "Imaginary part of: ctanh (5680 + 1 i)": ildouble: 1 ldouble: 1 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_upward -Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 idouble: 1 ildouble: 8 ldouble: 8 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # erfc -Test "erfc (0.75) == 0.288844366346484868401062165408589223": +Test "erfc (0.75)": float: 1 ifloat: 1 -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": ildouble: 1 ldouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "erfc (0x1.ffffc8p+2) == 1.122671365033056305522366683719541099329e-29": +Test "erfc (0x1.ffffc8p+2)": ildouble: 1 ldouble: 1 -Test "erfc (1.25) == 0.0770998717435417698634765188027188596": +Test "erfc (1.25)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": float: 1 ifloat: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_downward -Test "exp_downward (1) == e": +Test "exp_downward (1)": ildouble: 1 ldouble: 1 -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": double: 1 float: 1 idouble: 1 @@ -5194,17 +5194,17 @@ ildouble: 1 ldouble: 1 # exp_towardzero -Test "exp_towardzero (1) == e": +Test "exp_towardzero (1)": ildouble: 1 ldouble: 1 -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": double: 1 float: 1 idouble: 1 @@ -5213,417 +5213,417 @@ ildouble: 1 ldouble: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": double: 1 float: 1 idouble: 1 ifloat: 1 # expm1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": ildouble: 1 ldouble: 1 # gamma -Test "gamma (-0.5) == log(2*sqrt(pi))": +Test "gamma (-0.5)": ildouble: 1 ldouble: 1 -Test "gamma (0.5) == log(sqrt(pi))": +Test "gamma (0.5)": ildouble: 1 ldouble: 1 -Test "gamma (3) == M_LN2l": +Test "gamma (3)": ildouble: 1 ldouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-0x1.001000001p+593) == -3.927269966354206207832593635798954916263e-90": +Test "j0 (-0x1.001000001p+593)": ildouble: 2 ldouble: 2 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 -Test "j0 (0x1p1023) == -1.5665258060609012834424478437196679802783e-155": +Test "j0 (0x1p1023)": double: 1 idouble: 1 -Test "j0 (0x1p16382) == -1.2193782500509000574176799046642541129387e-2466": +Test "j0 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "j0 (1.5) == 0.511827671735918128749051744283411720": +Test "j0 (1.5)": float: 1 ifloat: 1 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 1 idouble: 1 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (-1.0) == -0.440050585744933515959682203718914913": +Test "j1 (-1.0)": float: 1 ifloat: 1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "j1 (0x1p16382) == 8.0839224448726336195866026476176740513439e-2467": +Test "j1 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "j1 (1.0) == 0.440050585744933515959682203718914913": +Test "j1 (1.0)": float: 1 ifloat: 1 -Test "j1 (1.5) == 0.557936507910099641990121213156089400": +Test "j1 (1.5)": float: 1 ifloat: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": float: 1 ifloat: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 1.5) == 0.511827671735918128749051744283411720": +Test "jn (0, 1.5)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 1 idouble: 1 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, -1.0) == -0.440050585744933515959682203718914913": +Test "jn (1, -1.0)": float: 1 ifloat: 1 -Test "jn (1, 1.0) == 0.440050585744933515959682203718914913": +Test "jn (1, 1.0)": float: 1 ifloat: 1 -Test "jn (1, 1.5) == 0.557936507910099641990121213156089400": +Test "jn (1, 1.5)": float: 1 ifloat: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": float: 1 ifloat: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": float: 1 ifloat: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 1 float: 5 idouble: 1 ifloat: 5 ildouble: 2 ldouble: 2 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": float: 3 ifloat: 3 ildouble: 1 ldouble: 1 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, -1.0) == -0.0195633539826684059189053216217515083": +Test "jn (3, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 1.0) == 0.0195633539826684059189053216217515083": +Test "jn (3, 1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 3 ldouble: 3 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": float: 4 ifloat: 4 ildouble: 1 ldouble: 1 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": float: 5 ifloat: 5 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": float: 4 ifloat: 4 ildouble: 2 ldouble: 2 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": float: 3 ifloat: 3 ildouble: 2 ldouble: 2 # lgamma -Test "lgamma (-0.5) == log(2*sqrt(pi))": +Test "lgamma (-0.5)": ildouble: 1 ldouble: 1 -Test "lgamma (0.5) == log(sqrt(pi))": +Test "lgamma (0.5)": ildouble: 1 ldouble: 1 -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "lgamma (3) == M_LN2l": +Test "lgamma (3)": ildouble: 1 ldouble: 1 # log -Test "log (0.75) == -0.287682072451780927439219005993827432": +Test "log (0.75)": ildouble: 1 ldouble: 1 -Test "log (2) == M_LN2l": +Test "log (2)": ildouble: 1 ldouble: 1 -Test "log (e) == 1": +Test "log (e)": float: 1 ifloat: 1 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": ildouble: 2 ldouble: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": ildouble: 1 ldouble: 1 # log2 -Test "log2 (0.75) == -.415037499278843818546261056052183492": +Test "log2 (0.75)": ildouble: 1 ldouble: 1 # pow -Test "pow (0.75, 1.25) == 0.697953644326574699205914060237425566": +Test "pow (0.75, 1.25)": ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1p64, 0.125) == 256": +Test "pow (0x1p64, 0.125)": ildouble: 1 ldouble: 1 -Test "pow (256, 8) == 0x1p64": +Test "pow (256, 8)": float: 1 ifloat: 1 ildouble: 7 ldouble: 7 # pow_downward -Test "pow_downward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_downward (1.0625, 1.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # pow_towardzero -Test "pow_towardzero (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_towardzero (1.0625, 1.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "pow_upward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_upward (1.5, 1.03125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # sin_downward -Test "sin_downward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_downward (1)": ildouble: 1 ldouble: 1 -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_downward (2)": double: 1 idouble: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": ildouble: 1 ldouble: 1 -Test "sin_downward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_downward (4)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (7) == 0.6569865987187890903969990915936351779369": +Test "sin_downward (7)": ildouble: 1 ldouble: 1 -Test "sin_downward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_downward (8)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_downward (9)": double: 1 float: 1 idouble: 1 @@ -5632,33 +5632,33 @@ ildouble: 1 ldouble: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (2) == 0.9092974268256816953960198659117448427023": +Test "sin_towardzero (2)": double: 1 idouble: 1 -Test "sin_towardzero (3) == 0.1411200080598672221007448028081102798469": +Test "sin_towardzero (3)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 -Test "sin_towardzero (7) == 0.6569865987187890903969990915936351779369": +Test "sin_towardzero (7)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (8) == 0.9893582466233817778081235982452886721164": +Test "sin_towardzero (8)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": double: 1 float: 1 idouble: 1 @@ -5667,55 +5667,55 @@ ildouble: 1 ldouble: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sin_upward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_upward (10)": float: 1 ifloat: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_upward (3)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 -Test "sin_upward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_upward (5)": float: 1 ifloat: 1 -Test "sin_upward (7) == 0.6569865987187890903969990915936351779369": +Test "sin_upward (7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sin_upward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_upward (8)": float: 1 ifloat: 1 # sincos -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 2": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sincos (pi/2, &sin_res, &cos_res) puts 0 in cos_res": +Test "sincos (pi/2) extra output 2": double: 1 float: 1 idouble: 1 @@ -5724,426 +5724,426 @@ ildouble: 1 ldouble: 1 # sinh -Test "sinh (0.75) == 0.822316731935829980703661634446913849": +Test "sinh (0.75)": ildouble: 1 ldouble: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sinh_upward -Test "sinh_upward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_upward (24)": double: 1 idouble: 1 # tan -Test "tan (0.75) == 0.931596459944072461165202756573936428": +Test "tan (0.75)": ildouble: 1 ldouble: 1 -Test "tan (pi/4) == 1": +Test "tan (pi/4)": double: 1 idouble: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tan_downward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_downward (3)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (4) == 1.1578212823495775831373424182673239231198": +Test "tan_downward (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_downward (5)": ildouble: 1 ldouble: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tan_downward (7) == 0.8714479827243187364564508896003135663222": +Test "tan_downward (7)": double: 1 idouble: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_towardzero -Test "tan_towardzero (1) == 1.5574077246549022305069748074583601730873": +Test "tan_towardzero (1)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (2) == -2.1850398632615189916433061023136825434320": +Test "tan_towardzero (2)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tan_towardzero (6) == -0.2910061913847491570536995888681755428312": +Test "tan_towardzero (6)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (7) == 0.8714479827243187364564508896003135663222": +Test "tan_towardzero (7)": double: 1 idouble: 1 -Test "tan_towardzero (8) == -6.7997114552203786999252627596086333648814": +Test "tan_towardzero (8)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": ildouble: 1 ldouble: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": double: 1 idouble: 1 -Test "tan_upward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_upward (2)": ildouble: 1 ldouble: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 -Test "tan_upward (4) == 1.1578212823495775831373424182673239231198": +Test "tan_upward (4)": double: 1 idouble: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tan_upward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_upward (6)": ildouble: 1 ldouble: 1 -Test "tan_upward (7) == 0.8714479827243187364564508896003135663222": +Test "tan_upward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_upward (8)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_upward (9)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (4) == 6": +Test "tgamma (4)": ildouble: 1 ldouble: 1 # y0 -Test "y0 (0.125) == -1.38968062514384052915582277745018693": +Test "y0 (0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (0.75) == -0.137172769385772397522814379396581855": +Test "y0 (0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-100) == -4.420092432563900590456563035154802121284e+1": +Test "y0 (0x1p-100)": float: 1 ifloat: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": float: 1 ifloat: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-60) == -2.6550076313426878432849115782108205929120e+1": +Test "y0 (0x1p-60)": double: 1 idouble: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-90) == -3.9788212322585974036636501709188067393195e+1": +Test "y0 (0x1p-90)": float: 1 ifloat: 1 -Test "y0 (0x1p16382) == 8.0839224448726336195866026476176740513439e-2467": +Test "y0 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": ildouble: 1 ldouble: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (2.0) == 0.510375672649745119596606592727157873": +Test "y0 (2.0)": float: 1 ifloat: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.001000001p+593) == 3.927269966354206207832593635798954916263e-90": +Test "y1 (0x1.001000001p+593)": ildouble: 2 ldouble: 2 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": float: 1 ifloat: 1 -Test "y1 (0x1p1023) == 1.5665258060609012834424478437196679802783e-155": +Test "y1 (0x1p1023)": double: 1 idouble: 1 -Test "y1 (0x1p16382) == 1.2193782500509000574176799046642541129387e-2466": +Test "y1 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "y1 (1.0) == -0.781212821300288716547150000047964821": +Test "y1 (1.0)": double: 1 idouble: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": float: 1 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # yn -Test "yn (0, 0.125) == -1.38968062514384052915582277745018693": +Test "yn (0, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 0.75) == -0.137172769385772397522814379396581855": +Test "yn (0, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": ildouble: 1 ldouble: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 2.0) == 0.510375672649745119596606592727157873": +Test "yn (0, 2.0)": float: 1 ifloat: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 0.75) == -1.03759455076928541973767132140642198": +Test "yn (1, 0.75)": float: 1 ifloat: 1 -Test "yn (1, 1.0) == -0.781212821300288716547150000047964821": +Test "yn (1, 1.0)": double: 1 idouble: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": float: 1 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": float: 1 ifloat: 1 ildouble: 4 ldouble: 4 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": ildouble: 1 ldouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": float: 1 ifloat: 1 diff --git a/libc/ports/sysdeps/microblaze/Makefile b/libc/ports/sysdeps/microblaze/Makefile index cc82a7482..f7c95ae11 100644 --- a/libc/ports/sysdeps/microblaze/Makefile +++ b/libc/ports/sysdeps/microblaze/Makefile @@ -9,18 +9,3 @@ endif ifeq ($(subdir),resource) sysdep_routines += backtrace_linux endif - -$(objpfx)libm.so: $(elfobjdir)/ld.so -$(objpfx)libcrypt.so: $(elfobjdir)/ld.so -$(objpfx)libresolv.so: $(elfobjdir)/ld.so -$(objpfx)libnss_dns.so: $(elfobjdir)/ld.so -$(objpfx)libnss_files.so: $(elfobjdir)/ld.so -$(objpfx)libnss_db.so: $(elfobjdir)/ld.so -$(objpfx)libnss_nis.so: $(elfobjdir)/ld.so -$(objpfx)libnss_nisplus.so: $(elfobjdir)/ld.so -$(objpfx)libnss_hesiod.so: $(elfobjdir)/ld.so -$(objpfx)libnss_compat.so: $(elfobjdir)/ld.so -$(objpfx)libanl.so: $(elfobjdir)/ld.so -$(objpfx)libnsl.so: $(elfobjdir)/ld.so -$(objpfx)libcidn.so: $(elfobjdir)/ld.so -$(objpfx)libutil.so: $(elfobjdir)/ld.so diff --git a/libc/ports/sysdeps/microblaze/dl-machine.h b/libc/ports/sysdeps/microblaze/dl-machine.h index 7471bdd84..ad1fc3ef3 100644 --- a/libc/ports/sysdeps/microblaze/dl-machine.h +++ b/libc/ports/sysdeps/microblaze/dl-machine.h @@ -240,8 +240,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc, strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/ports/sysdeps/microblaze/libm-test-ulps b/libc/ports/sysdeps/microblaze/libm-test-ulps index 9fde9b195..9820f51ee 100644 --- a/libc/ports/sysdeps/microblaze/libm-test-ulps +++ b/libc/ports/sysdeps/microblaze/libm-test-ulps @@ -1,1404 +1,1404 @@ # Begin of automatic generation # atan2 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-1.0 + 0x1p50 i) == 1.570796326794897507409741391764983781004 - 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-1.0 + 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-1.0 - 0x1p50 i) == 1.570796326794897507409741391764983781004 + 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-1.0 - 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-2 - 3 i) == 2.1414491111159960199416055713254211 + 1.9833870299165354323470769028940395 i": +Test "Real part of: cacos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 - 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 - 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 + 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 + 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 # casinh -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 # cbrt -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 # cexp -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": float: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 ifloat: 1 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 ifloat: 2 # csin -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # csinh -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 # ctan_tonearest -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 2 ifloat: 2 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 idouble: 1 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 1 idouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 1 idouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 # expm1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": float: 1 ifloat: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # fma -Test "fma (-0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983) == 0x1.7ffffe00007ffp-983": +Test "fma (-0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983)": double: 1 idouble: 1 -Test "fma (0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300) == 0x1.fffffffffffffp-1": +Test "fma (0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300)": double: 1 idouble: 1 -Test "fma (0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022) == -0x0.b22757123bbe9p-1022": +Test "fma (0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022)": double: 1 idouble: 1 -Test "fma (0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022) == 0x0.0000010000003p-1022": +Test "fma (0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022)": double: 1 idouble: 1 -Test "fma (0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24) == 0x1.7ff802p+13": +Test "fma (0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24)": float: 1 ifloat: 1 -Test "fma (0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022) == 0x0.0000010000001p-1022": +Test "fma (0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022)": double: 1 idouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 ifloat: 2 # lgamma -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 ifloat: 2 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # pow -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # y0 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/ports/sysdeps/mips/dl-lookup.c b/libc/ports/sysdeps/mips/dl-lookup.c index 02090e5e5..6d8f74424 100644 --- a/libc/ports/sysdeps/mips/dl-lookup.c +++ b/libc/ports/sysdeps/mips/dl-lookup.c @@ -114,7 +114,7 @@ do_lookup_x (const char *undef_name, uint_fast32_t new_hash, if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_SYMBOLS, 0)) _dl_debug_printf ("symbol=%s; lookup in file=%s [%lu]\n", undef_name, - map->l_name[0] ? map->l_name : rtld_progname, + DSO_FILENAME (map->l_name), map->l_ns); /* If the hash table is empty there is nothing to do here. */ @@ -684,10 +684,9 @@ add_dependency (struct link_map *undef_map, struct link_map *map, int flags) if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_FILES, 0)) _dl_debug_printf ("\ \nfile=%s [%lu]; needed by %s [%lu] (relocation dependency)\n\n", - map->l_name[0] ? map->l_name : rtld_progname, + DSO_FILENAME (map->l_name), map->l_ns, - undef_map->l_name[0] - ? undef_map->l_name : rtld_progname, + DSO_FILENAME (undef_map->l_name), undef_map->l_ns); } else @@ -768,9 +767,7 @@ _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map, const char *reference_name = undef_map ? undef_map->l_name : NULL; /* XXX We cannot translate the message. */ - _dl_signal_cerror (0, (reference_name[0] - ? reference_name - : (rtld_progname ?: "<main program>")), + _dl_signal_cerror (0, DSO_FILENAME (reference_name), N_("relocation error"), make_string ("symbol ", undef_name, ", version ", version->name, @@ -797,9 +794,7 @@ _dl_lookup_symbol_x (const char *undef_name, struct link_map *undef_map, ? version->name : ""); /* XXX We cannot translate the message. */ - _dl_signal_cerror (0, (reference_name[0] - ? reference_name - : (rtld_progname ?: "<main program>")), + _dl_signal_cerror (0, DSO_FILENAME (reference_name), N_("symbol lookup error"), make_string (undefined_msg, undef_name, versionstr, versionname)); @@ -929,11 +924,9 @@ _dl_debug_bindings (const char *undef_name, struct link_map *undef_map, if (GLRO(dl_debug_mask) & DL_DEBUG_BINDINGS) { _dl_debug_printf ("binding file %s [%lu] to %s [%lu]: %s symbol `%s'", - (reference_name[0] - ? reference_name - : (rtld_progname ?: "<main program>")), + DSO_FILENAME (reference_name), undef_map->l_ns, - value->m->l_name[0] ? value->m->l_name : rtld_progname, + DSO_FILENAME (value->m->l_name), value->m->l_ns, protected ? "protected" : "normal", undef_name); if (version) diff --git a/libc/ports/sysdeps/mips/dl-machine.h b/libc/ports/sysdeps/mips/dl-machine.h index a7c784fec..dae938f03 100644 --- a/libc/ports/sysdeps/mips/dl-machine.h +++ b/libc/ports/sysdeps/mips/dl-machine.h @@ -635,8 +635,7 @@ elf_machine_reloc (struct link_map *map, ElfW(Addr) r_info, strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/ports/sysdeps/mips/mips32/libm-test-ulps b/libc/ports/sysdeps/mips/mips32/libm-test-ulps index e0c7e0d47..990a5bc82 100644 --- a/libc/ports/sysdeps/mips/mips32/libm-test-ulps +++ b/libc/ports/sysdeps/mips/mips32/libm-test-ulps @@ -1,1785 +1,1785 @@ # Begin of automatic generation # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 # asin_upward -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 # atan2 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # casinh -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 # cbrt -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 # cexp -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": float: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 ifloat: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cos_towardzero -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 # cos_upward -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 ifloat: 2 # csin -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # csinh -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctan_tonearest -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 ifloat: 2 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 2 ifloat: 2 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 idouble: 1 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 # ctanh_upward -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 1 idouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 1 idouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 # exp_downward -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 # exp_towardzero -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 # expm1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": float: 1 ifloat: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 ifloat: 2 # lgamma -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 ifloat: 2 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # pow -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 # pow_downward -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 # pow_towardzero -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 # sin_downward -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_towardzero -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": float: 1 ifloat: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": float: 1 ifloat: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # y0 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/ports/sysdeps/mips/mips64/libm-test-ulps b/libc/ports/sysdeps/mips/mips64/libm-test-ulps index c7a18d666..399d32410 100644 --- a/libc/ports/sysdeps/mips/mips64/libm-test-ulps +++ b/libc/ports/sysdeps/mips/mips64/libm-test-ulps @@ -1,195 +1,195 @@ # Begin of automatic generation # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 # asin_upward -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 # atan2 -Test "atan2 (-0.00756827042671106339, -.001792735857538728036) == -1.80338464113663849327153994379639112": +Test "atan2 (-0.00756827042671106339, -.001792735857538728036)": ildouble: 1 ldouble: 1 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: cacos (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 @@ -198,179 +198,179 @@ ildouble: 1 ldouble: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: casin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 @@ -379,939 +379,939 @@ ildouble: 1 ldouble: 1 # casinh -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (0.75 + 1.25 i) == 1.10714871779409050301706546017853704 + 0.549306144334054845697622618461262852 i": +Test "Imaginary part of: catan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Imaginary part of: catanh (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 # cbrt -Test "cbrt (-0.001) == -0.1": +Test "cbrt (-0.001)": ildouble: 1 ldouble: 1 -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 11357.25 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (-0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 11357.25 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (-0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Real part of: ccos (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 11357.25 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 11357.25 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0x1p-16434 + 22730 i) == inf - 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: ccos (0x1p-16434 + 22730 i)": ildouble: 1 ldouble: 1 # ccosh -Test "Imaginary part of: ccosh (-11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (-11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (-11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (22730 + 0x1p-16434 i) == inf + 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: ccosh (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cexp -Test "Imaginary part of: cexp (-10000 + 0x1p16383 i) == 1.045876464564882298442774542991176546722e-4343 + 4.421154026488516836023811173959413420548e-4344 i": +Test "Imaginary part of: cexp (-10000 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Real part of: cexp (-2.0 - 3.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-720 + 0.75 i) == 1.486960657116368433685753325516638551722e-313 + 1.385247284245720590980701226843815229385e-313 i": +Test "Imaginary part of: cexp (-720 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (22730 + 0x1p-16434 i) == inf + 2.435706297811211974162115164702304105374e4924 i": +Test "Imaginary part of: cexp (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16494 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16494 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16494 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16494 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16494 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16494 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i) == 11356.83823118610934184548269774874545400 + pi/4 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16494 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16494 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 3.2047474274603604594851472963586149973093e-29 + 1.4422922682185099608731642353544207976604 i": +Test "Imaginary part of: clog (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16494 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16494 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16494 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16494 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i) == -1.1931267660846218205882675852805793644095e-36 + 1.2402109774337032400594953899784058127412 i": +Test "Imaginary part of: clog (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2ede88p-23 + 0x771c3fp-23 i) == -4.4764192352906350039050902870893173560494e-13 + 1.1959106857549200806818600493552847793381 i": +Test "Imaginary part of: clog (0x2ede88p-23 + 0x771c3fp-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i) == -1.0509738482436128031927971874674370984602e-45 + 1.0509191467640012308402149909370784281448 i": +Test "Imaginary part of: clog (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i) == -5.2000108498455368032511404449795741611813e-32 + 1.5288921536982513453421343495466824420259 i": +Test "Imaginary part of: clog (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 8.3076914081087805757422664530653247447136e-30 + 1.2072712126771536614482822173033535043206 i": +Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x659feap-24 + 0xeaf6f9p-24 i) == 3.7303493627403868207597214252239749960738e-14 + 1.1625816408046866464773042283673653469061 i": +Test "Imaginary part of: clog (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6771f22c64ed551b857c128b4cp-105 + 0x1f570e7a13cc3cf2f44fd793ea1p-105 i) == -1.4281333889622737316199756373421183559948e-62 + 1.3673546561165378090903506783353927980633 i": +Test "Imaginary part of: clog (0x6771f22c64ed551b857c128b4cp-105 + 0x1f570e7a13cc3cf2f44fd793ea1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 2.4244570985709679851855191080208817099132e-37 + 1.1393074519572050614551047548718495655972 i": +Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i) == -9.7375017988218644730510244778042114638107e-30 + 0.9790637929494922564724108399524154766631 i": +Test "Real part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x9b57bp-20 + 0xcb7b4p-20 i) == -3.9563019528687610863490232935890272740908e-11 + 0.9187593477446338910857133065497364950682 i": +Test "Imaginary part of: clog (0x9b57bp-20 + 0xcb7b4p-20 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i) == 4.6017338806965821566734340588575402712716e-67 + 1.3547418904611758959096647942223384691728 i": +Test "Imaginary part of: clog (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i) == 6.6255694866654064502633121109394710807528e-66 + 1.0526409614996288387567810726095850312049 i": +Test "Imaginary part of: clog (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 5.3718272201930019901317065495843842735179e-26 + 1.0503831592447830576186444373011142397404 i": +Test "Imaginary part of: clog (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Real part of: clog10 (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Imaginary part of: clog10 (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i) == 4.285899851347756186652871946325962330640e-19 + 4.611541215247321502041995872887317363241e-302 i": +Test "Real part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i) == 4.285899851347756186652871946325962330640e-19 + 4.611541215247321502041995872887317363241e-302 i": +Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-60 i) == 4.285899851347756188767674032946882584784e-19 + 4.285899850759344225805480528847018395861e-19 i": +Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-60 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Real part of: clog10 (0x1.234566p-50 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Real part of: clog10 (0x1.234566p-60 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 308.4052305577487344482591243175787477115 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i) == 4932.212175672014259683102930239951947672 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i) == 4932.112944269463028900262609694408579449 + 0.2069271710841128115912940666587802677383 i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1415bcaf2105940d49a636e98ae59p-115 + 0x7e6a150adfcd1b0921d44b31f40f4p-115 i) == 1.1288799405048268615023706955013387413519e-67 + 0.6137587762850841972073301550420510507903 i": +Test "Real part of: clog10 (0x1415bcaf2105940d49a636e98ae59p-115 + 0x7e6a150adfcd1b0921d44b31f40f4p-115 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i) == 4.4163015461643576961232672330852798804976e-31 + 0.3564851427422832755956993418877523303529 i": +Test "Imaginary part of: clog10 (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Real part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i) == -322.8546703496198318667349645920187712089 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i) == -4.5643214291682663316715446865040356750881e-46 + 0.4564083863660793840592614609053162690362 i": +Test "Imaginary part of: clog10 (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i) == 2.7822833698845776001753149807484078521508e-37 + 0.3992725998539071066769046272515417679815 i": +Test "Real part of: clog10 (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i) == -2.2583360179249556400630343805573865814771e-32 + 0.6639894257763289307423302343317622430835 i": +Test "Real part of: clog10 (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i) == -1.0146400362652473358437501879334790111898e-37 + 0.5149047982335273098246594109614460842099 i": +Test "Real part of: clog10 (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i) == 1.8804859395820231849002915747252695375405e-63 + 0.6404513901551516189871978418046651877394 i": +Test "Real part of: clog10 (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Real part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 1.0529283395205396881397407610630442563938e-37 + 0.4947949395762683446121140513971996916447 i": +Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i) == 1.9985076315737626043096596036300177494613e-67 + 0.5883569274304683249184005177865521205198 i": +Test "Real part of: clog10 (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i) == 2.8774482675253468630312378575186855052697e-66 + 0.4571561610046221605554903008571429975493 i": +Test "Imaginary part of: clog10 (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 @@ -1320,138 +1320,138 @@ ildouble: 1 ldouble: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cos_towardzero -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 # cos_upward -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 # cosh_tonearest -Test "cosh_tonearest (22) == 1792456423.065795780980053377632656584997": +Test "cosh_tonearest (22)": ildouble: 1 ldouble: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 # cosh_upward -Test "cosh_upward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_upward (22)": ildouble: 1 ldouble: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 4 ldouble: 4 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 ildouble: 2 ldouble: 2 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 @@ -1460,380 +1460,380 @@ ildouble: 1 ldouble: 1 # csin -Test "Real part of: csin (-0.75 + 11357.25 i) == -8.385498349388321535962327491346664141020e4931 + 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (-0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 11357.25 i) == -8.385498349388321535962327491346664141020e4931 - 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (-0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-2 - 3 i) == -9.15449914691142957346729954460983256 + 4.16890695996656435075481305885375484 i": +Test "Imaginary part of: csin (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Real part of: csin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 11357.25 i) == 8.385498349388321535962327491346664141020e4931 + 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 11357.25 i) == 8.385498349388321535962327491346664141020e4931 - 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 -Test "Real part of: csin (0x1p-16434 + 22730 i) == 1.217853148905605987081057582351152052687e4924 + inf i": +Test "Real part of: csin (0x1p-16434 + 22730 i)": ildouble: 1 ldouble: 1 # csinh -Test "Imaginary part of: csinh (-11357.25 + 0.75 i) == -9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (-11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-11357.25 - 0.75 i) == -9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (-11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Real part of: csinh (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (22730 + 0x1p-16434 i) == inf + 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: csinh (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # csqrt -Test "Real part of: csqrt (-0x1.0000000000000000000000000001p-16382 - 0x1.0000000000000000000000000001p-16382 i) == 8.344545284118961663847948339519226074126e-2467 - 2.014551439675644900022606748976158925145e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000000000000000001p-16382 - 0x1.0000000000000000000000000001p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i) == 6.788430486774966350907249113759995429568e-155 - 1.638872094839911521020410942677082920935e-154 i": +Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0.75 + 1.25 i) == 1.05065169626078392338656675760808326 + 0.594868882070379067881984030639932657 i": +Test "Imaginary part of: csqrt (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i) == 2.014551439675644900022606748976158925145e-2466 + 8.344545284118961663847948339519226074126e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i) == 1.638872094839911521020410942677082920935e-154 + 6.788430486774966350907249113759995429568e-155 i": +Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Real part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1p+16383 i) == 1.106698967236475180613254276996359485630e+2466 + 2.687568007603946993388538156299100955642e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-16440 + 0x1p-16441 i) == 3.514690655930285351254618340783294558136e-2475 + 8.297059146828716918029689466551384219370e-2476 i": +Test "Imaginary part of: csqrt (0x1p-16440 + 0x1p-16441 i)": ildouble: 1 ldouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Real part of: ctan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Imaginary part of: ctan (0x1p1023 + 1 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Real part of: ctan (0x1p127 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Real part of: ctan (0x1p16383 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Imaginary part of: ctan (0x1p16383 + 1 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 355 i) == 8.140551093483276762350406321792653551513e-309 + 1.0 i": +Test "Real part of: ctan (1 + 355 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 365 i) == 1.677892637497921890115075995898773550884e-317 + 1.0 i": +Test "Real part of: ctan (1 + 365 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 45 i) == 1.490158918874345552942703234806348520895e-39 + 1.000000000000000000000000000000000000001 i": +Test "Real part of: ctan (1 + 45 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 47 i) == 2.729321264492904590777293425576722354636e-41 + 1.0 i": +Test "Real part of: ctan (1 + 47 i)": ildouble: 1 ldouble: 1 # ctan_downward -Test "Imaginary part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # ctan_tonearest -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # ctan_towardzero -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # ctan_upward -Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 @@ -1842,515 +1842,515 @@ ildouble: 2 ldouble: 2 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 2 ifloat: 2 -Test "Real part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Real part of: ctanh (1 + 0x1p1023 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Imaginary part of: ctanh (1 + 0x1p127 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Real part of: ctanh (1 + 0x1p16383 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Imaginary part of: ctanh (1 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (355 + 1 i) == 1.0 + 8.140551093483276762350406321792653551513e-309 i": +Test "Imaginary part of: ctanh (355 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (365 + 1 i) == 1.0 + 1.677892637497921890115075995898773550884e-317 i": +Test "Imaginary part of: ctanh (365 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (45 + 1 i) == 1.000000000000000000000000000000000000001 + 1.490158918874345552942703234806348520895e-39 i": +Test "Imaginary part of: ctanh (45 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (47 + 1 i) == 1.0 + 2.729321264492904590777293425576722354636e-41 i": +Test "Imaginary part of: ctanh (47 + 1 i)": ildouble: 1 ldouble: 1 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_upward -Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 3 ldouble: 3 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "erfc (0x1.ffffc8p+2) == 1.122671365033056305522366683719541099329e-29": +Test "erfc (0x1.ffffc8p+2)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (27.0) == 0.523704892378925568501606768284954709e-318": +Test "erfc (27.0)": ildouble: 1 ldouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 1 idouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 1 idouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 -Test "exp10 (4932) == 1.0e4932": +Test "exp10 (4932)": ildouble: 1 ldouble: 1 # exp2 -Test "exp2 (100.5) == 1.792728671193156477399422023278661496394e+30": +Test "exp2 (100.5)": ildouble: 1 ldouble: 1 # exp_downward -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 # exp_towardzero -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 # expm1 -Test "expm1 (-79.0) == -0.9999999999999999999999999999999999509391": +Test "expm1 (-79.0)": ildouble: 1 ldouble: 1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # gamma -Test "gamma (-0.5) == log(2*sqrt(pi))": +Test "gamma (-0.5)": ildouble: 1 ldouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-0x1.001000001p+593) == -3.927269966354206207832593635798954916263e-90": +Test "j0 (-0x1.001000001p+593)": ildouble: 1 ldouble: 1 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # j1 -Test "j1 (-1.0) == -0.440050585744933515959682203718914913": +Test "j1 (-1.0)": ildouble: 1 ldouble: 1 -Test "j1 (0.75) == 0.349243602174862192523281016426251335": +Test "j1 (0.75)": ildouble: 1 ldouble: 1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (1.0) == 0.440050585744933515959682203718914913": +Test "j1 (1.0)": ildouble: 1 ldouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (1, -1.0) == -0.440050585744933515959682203718914913": +Test "jn (1, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (1, 0.75) == 0.349243602174862192523281016426251335": +Test "jn (1, 0.75)": ildouble: 1 ldouble: 1 -Test "jn (1, 1.0) == 0.440050585744933515959682203718914913": +Test "jn (1, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 2 ldouble: 2 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 5 ldouble: 5 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 ildouble: 3 ldouble: 3 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 ildouble: 8 ldouble: 8 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 @@ -2359,17 +2359,17 @@ ildouble: 3 ldouble: 3 # lgamma -Test "lgamma (-0.5) == log(2*sqrt(pi))": +Test "lgamma (-0.5)": ildouble: 1 ldouble: 1 -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -2378,327 +2378,327 @@ ildouble: 1 ldouble: 1 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # log2 -Test "log2 (0.75) == -.415037499278843818546261056052183492": +Test "log2 (0.75)": ildouble: 1 ldouble: 1 # pow -Test "pow (0x0.fffffffffffff8p0, -0x1.23456789abcdfp62) == 9.8826311568054561811190162420900667121992e+252": +Test "pow (0x0.fffffffffffff8p0, -0x1.23456789abcdfp62)": ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (10.0, -4930.0) == 1e-4930": +Test "pow (10.0, -4930.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4929.0) == 1e4929": +Test "pow (10.0, 4929.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4930.0) == 1e4930": +Test "pow (10.0, 4930.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4931.0) == 1e4931": +Test "pow (10.0, 4931.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4932.0) == 1e4932": +Test "pow (10.0, 4932.0)": ildouble: 1 ldouble: 1 -Test "pow (1e4932, 0.75) == 1e3699": +Test "pow (1e4932, 0.75)": ildouble: 1 ldouble: 1 # pow_downward -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 # pow_towardzero -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 # sin_downward -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 -Test "sin_tonearest (3) == 0.1411200080598672221007448028081102798469": +Test "sin_tonearest (3)": ildouble: 1 ldouble: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (3) == 0.1411200080598672221007448028081102798469": +Test "sin_towardzero (3)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 -Test "sin_upward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_upward (3)": ildouble: 1 ldouble: 1 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_towardzero -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": float: 1 ifloat: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": float: 1 ifloat: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 # tanh -Test "tanh (-0.75) == -0.635148952387287319214434357312496495": +Test "tanh (-0.75)": ildouble: 1 ldouble: 1 -Test "tanh (-1.0) == -0.7615941559557648881194582826047935904": +Test "tanh (-1.0)": ildouble: 1 ldouble: 1 -Test "tanh (0.75) == 0.635148952387287319214434357312496495": +Test "tanh (0.75)": ildouble: 1 ldouble: 1 -Test "tanh (1.0) == 0.7615941559557648881194582826047935904": +Test "tanh (1.0)": ildouble: 1 ldouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (4) == 6": +Test "tgamma (4)": ildouble: 1 ldouble: 1 # y0 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-60) == -2.6550076313426878432849115782108205929120e+1": +Test "y0 (0x1p-60)": ildouble: 1 ldouble: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -2707,44 +2707,44 @@ ildouble: 3 ldouble: 3 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0.75) == -1.03759455076928541973767132140642198": +Test "y1 (0.75)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.001000001p+593) == 3.927269966354206207832593635798954916263e-90": +Test "y1 (0x1.001000001p+593)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y1 (0x1p-30) == -6.8356527557643159612937462812258975438856e+08": +Test "y1 (0x1p-30)": ildouble: 1 ldouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 @@ -2753,105 +2753,105 @@ ildouble: 1 ldouble: 1 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 0.75) == -1.03759455076928541973767132140642198": +Test "yn (1, 0.75)": ildouble: 1 ldouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 ildouble: 2 ldouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/ports/sysdeps/powerpc/nofpu/libm-test-ulps b/libc/ports/sysdeps/powerpc/nofpu/libm-test-ulps index 652cad322..30cd04604 100644 --- a/libc/ports/sysdeps/powerpc/nofpu/libm-test-ulps +++ b/libc/ports/sysdeps/powerpc/nofpu/libm-test-ulps @@ -1,32 +1,32 @@ # Begin of automatic generation # acos -Test "acos (-0x0.ffffffff8p0) == 3.1415773948007305904329067627145550395696": +Test "acos (-0x0.ffffffff8p0)": ildouble: 1 ldouble: 1 -Test "acos (-0x0.ffffffp0) == 3.1412473866050770348750401337968641476999": +Test "acos (-0x0.ffffffp0)": ildouble: 1 ldouble: 1 -Test "acos (2e-17) == 1.57079632679489659923132169163975144": +Test "acos (2e-17)": ildouble: 1 ldouble: 1 # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 @@ -35,21 +35,21 @@ ildouble: 1 ldouble: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 @@ -58,1229 +58,1229 @@ ildouble: 1 ldouble: 1 # acos_upward -Test "acos_upward (-0) == pi/2": +Test "acos_upward (-0)": ildouble: 2 ldouble: 2 -Test "acos_upward (-1) == pi": +Test "acos_upward (-1)": ildouble: 2 ldouble: 2 -Test "acos_upward (0) == pi/2": +Test "acos_upward (0)": ildouble: 2 ldouble: 2 # asin -Test "asin (-0x0.ffffffff8p0) == -1.5707810680058339712015850710748035974710": +Test "asin (-0x0.ffffffff8p0)": ildouble: 1 ldouble: 1 -Test "asin (-0x0.ffffffp0) == -1.5704510598101804156437184421571127056013": +Test "asin (-0x0.ffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (0.75) == 0.848062078981481008052944338998418080": +Test "asin (0.75)": ildouble: 2 ldouble: 2 -Test "asin (0x0.ffffffff8p0) == 1.5707810680058339712015850710748035974710": +Test "asin (0x0.ffffffff8p0)": ildouble: 1 ldouble: 1 -Test "asin (0x0.ffffffp0) == 1.5704510598101804156437184421571127056013": +Test "asin (0x0.ffffffp0)": ildouble: 1 ldouble: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (-1.0) == -pi/2": +Test "asin_downward (-1.0)": ildouble: 1 ldouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 # asin_upward -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 -Test "asin_upward (1.0) == pi/2": +Test "asin_upward (1.0)": ildouble: 1 ldouble: 1 # atan2 -Test "atan2 (-0.00756827042671106339, -.001792735857538728036) == -1.80338464113663849327153994379639112": +Test "atan2 (-0.00756827042671106339, -.001792735857538728036)": ildouble: 1 ldouble: 1 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cabs -Test "cabs (0.75 + 1.25 i) == 1.45773797371132511771853821938639577": +Test "cabs (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-2 - 3 i) == -0.57065278432109940071028387968566963 - 1.9833870299165354323470769028940395 i": +Test "Real part of: casin (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # casinh -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 # catan -Test "Real part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Real part of: catan (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 # cbrt -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cexp -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Imaginary part of: cexp (500 + 0x1p1023 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-2 - 3 i) == 1.2824746787307683680267437207826593 - 2.1587989303424641704769327722648368 i": +Test "Imaginary part of: clog (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Imaginary part of: clog (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x11682p-23 + 0x7ffed1p-23 i) == 1.1723955140027907954461000991619077811832e-12 + 1.5622968405332756349813737986164832897108 i": +Test "Imaginary part of: clog (0x11682p-23 + 0x7ffed1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x13836d58a13448d750b4b9p-85 + 0x195ca7bc3ab4f9161edbe6p-85 i) == 2.8398125044729578740243199963484494962411e-50 + 0.9149964976334130461795060758257083099706 i": +Test "Imaginary part of: clog (0x13836d58a13448d750b4b9p-85 + 0x195ca7bc3ab4f9161edbe6p-85 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x155f8afc4c48685bf63610p-85 + 0x17d0cf2652cdbeb1294e19p-85 i) == -4.7775669192897997174762089350332738583822e-50 + 0.8393953487996880419413728440067635213372 i": +Test "Imaginary part of: clog (0x155f8afc4c48685bf63610p-85 + 0x17d0cf2652cdbeb1294e19p-85 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i) == 1.0168910106364605304135563536838075568606e-30 + 0.8208373755522359859870890246475340086663 i": +Test "Imaginary part of: clog (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i) == 6.4064442119814669184296141278612389400075e-37 + 0.9193591364645830864185131402313014890145 i": +Test "Imaginary part of: clog (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i) == 4.3299788920664682288477984749202524623248e-63 + 1.4746938237585656250866370987773473745867 i": +Test "Imaginary part of: clog (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xa1f2c1p-24 + 0xc643aep-24 i) == -1.0480505352462576151523512837107080269981e-13 + 0.8858771987699967480545613322309315260313 i": +Test "Imaginary part of: clog (0xa1f2c1p-24 + 0xc643aep-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xa4722f19346cp-51 + 0x7f9631c5e7f07p-51 i) == -6.2122796286154679676173624516405339768606e-30 + 1.4904138780720095276446375492434049214172 i": +Test "Imaginary part of: clog (0xa4722f19346cp-51 + 0x7f9631c5e7f07p-51 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xf2p-10 + 0x3e3p-10 i) == 6.1988446308070710970664736815277450078106e-06 + 1.3322126499153926210226335249558203898460 i": +Test "Imaginary part of: clog (0xf2p-10 + 0x3e3p-10 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 308.4052305577487344482591243175787477115 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x13836d58a13448d750b4b9p-85 + 0x195ca7bc3ab4f9161edbe6p-85 i) == 1.2333149003324592532859843519619084433953e-50 + 0.3973779298829931059309198145608711073016 i": +Test "Imaginary part of: clog10 (0x13836d58a13448d750b4b9p-85 + 0x195ca7bc3ab4f9161edbe6p-85 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x155f8afc4c48685bf63610p-85 + 0x17d0cf2652cdbeb1294e19p-85 i) == -2.0748709499710785084693619097712106753591e-50 + 0.3645447681189598740620098186365764884771 i": +Test "Imaginary part of: clog10 (0x155f8afc4c48685bf63610p-85 + 0x17d0cf2652cdbeb1294e19p-85 i)": ildouble: 2 ldouble: 2 -Test "Real part of: clog10 (0x15d8ab6ed05ca514086ac3a1e84p-105 + 0x1761e480aa094c0b10b34b09ce9p-105 i) == 4.3548095442952115860848857519953610343042e-63 + 0.3558376234889641500775150477035448866763 i": +Test "Real part of: clog10 (0x15d8ab6ed05ca514086ac3a1e84p-105 + 0x1761e480aa094c0b10b34b09ce9p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i) == -322.8546703496198318667349645920187712089 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i) == -5.1816837072162316773907242302011632570857e-37 + 0.5386167838952956925896424154370364458140 i": +Test "Imaginary part of: clog10 (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Imaginary part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x81b7efa81fc35ad1p-65 + 0x1ef4b835f1c79d812p-65 i) == -4.3074341162203896332989394770760901408798e-39 + 0.5709443672155660428417571212549720987784 i": +Test "Imaginary part of: clog10 (0x81b7efa81fc35ad1p-65 + 0x1ef4b835f1c79d812p-65 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xe33f66c9542ca25cc43c867p-95 + 0x7f35a68ebd3704a43c465864p-95 i) == 1.7850272475173865337808494725293124613817e-56 + 0.6338990862456906754888183278564382516852 i": +Test "Imaginary part of: clog10 (0xe33f66c9542ca25cc43c867p-95 + 0x7f35a68ebd3704a43c465864p-95 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 ifloat: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_downward (10)": ildouble: 1 ldouble: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 -Test "cos_downward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_downward (6)": ildouble: 1 ldouble: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "cos_downward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_downward (9)": ildouble: 1 ldouble: 1 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cos_towardzero -Test "cos_towardzero (1) == 0.5403023058681397174009366074429766037323": +Test "cos_towardzero (1)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (10) == -0.8390715290764524522588639478240648345199": +Test "cos_towardzero (10)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cos_upward -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_upward (4)": ildouble: 1 ldouble: 1 -Test "cos_upward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_upward (5)": ildouble: 1 ldouble: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_tonearest -Test "cosh_tonearest (24) == 13244561064.92173614708845674912733665919": +Test "cosh_tonearest (24)": ildouble: 1 ldouble: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_upward -Test "cosh_upward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_upward (22)": ildouble: 2 ldouble: 2 -Test "cosh_upward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_upward (23)": ildouble: 2 ldouble: 2 -Test "cosh_upward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_upward (24)": ildouble: 2 ldouble: 2 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 2 ldouble: 2 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 ildouble: 4 ldouble: 4 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 @@ -1289,224 +1289,224 @@ ildouble: 2 ldouble: 2 # csin -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # csinh -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # csqrt -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-1074 + 0x1p-1074 i) == 2.442109726130830256743814843868934877597e-162 + 1.011554969366634726113090867589031782487e-162 i": +Test "Imaginary part of: csqrt (0x1p-1074 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Imaginary part of: ctan (0x1p1023 + 1 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Real part of: ctan (0x1p127 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 47 i) == 2.729321264492904590777293425576722354636e-41 + 1.0 i": +Test "Real part of: ctan (1 + 47 i)": ildouble: 2 ldouble: 2 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 10 ldouble: 10 # ctan_tonearest -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 13 ldouble: 13 -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 10 ldouble: 10 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 6 ldouble: 6 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 10 ldouble: 10 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 @@ -1515,68 +1515,68 @@ ildouble: 1 ldouble: 1 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Real part of: ctanh (1 + 0x1p1023 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Imaginary part of: ctanh (1 + 0x1p127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (47 + 1 i) == 1.0 + 2.729321264492904590777293425576722354636e-41 i": +Test "Imaginary part of: ctanh (47 + 1 i)": ildouble: 2 ldouble: 2 # ctanh_downward -Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 10 ldouble: 10 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 @@ -1585,52 +1585,52 @@ ildouble: 3 ldouble: 3 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 13 ldouble: 13 -Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 4 ldouble: 4 -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 10 ldouble: 10 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # ctanh_upward -Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 10 ldouble: 10 -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 6 ldouble: 6 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 @@ -1639,319 +1639,319 @@ ildouble: 3 ldouble: 3 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 -Test "erfc (0x1.ffff56789abcdef0123456789a8p+2) == 1.123161416304655390092138725253789378459e-29": +Test "erfc (0x1.ffff56789abcdef0123456789a8p+2)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp -Test "exp (0.75) == 2.11700001661267466854536981983709561": +Test "exp (0.75)": ildouble: 1 ldouble: 1 -Test "exp (50.0) == 5184705528587072464087.45332293348538": +Test "exp (50.0)": ildouble: 1 ldouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 1 idouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 1 idouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 # exp_downward -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_towardzero -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # expm1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (0.75, 1.25) == 1.45773797371132511771853821938639577": +Test "hypot (0.75, 1.25)": ildouble: 1 ldouble: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-0x1.001000001p+593) == -3.927269966354206207832593635798954916263e-90": +Test "j0 (-0x1.001000001p+593)": ildouble: 2 ldouble: 2 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 4 ldouble: 4 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 4 ldouble: 4 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 ildouble: 2 ldouble: 2 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 ildouble: 4 ldouble: 4 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 @@ -1960,12 +1960,12 @@ ildouble: 7 ldouble: 7 # lgamma -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -1974,455 +1974,455 @@ ildouble: 3 ldouble: 3 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # log2 -Test "log2 (e) == M_LOG2El": +Test "log2 (e)": ildouble: 1 ldouble: 1 # pow -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 # pow_downward -Test "pow_downward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_downward (1.0625, 1.125)": ildouble: 1 ldouble: 1 -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 # pow_towardzero -Test "pow_towardzero (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_towardzero (1.0625, 1.125)": ildouble: 1 ldouble: 1 -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 -Test "pow_upward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_upward (1.5, 1.03125)": ildouble: 1 ldouble: 1 # sin_downward -Test "sin_downward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_downward (1)": ildouble: 4 ldouble: 4 -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 -Test "sin_downward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_downward (2)": ildouble: 1 ldouble: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sin_downward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_downward (4)": ildouble: 1 ldouble: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 -Test "sin_downward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_downward (8)": ildouble: 1 ldouble: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (2) == 0.9092974268256816953960198659117448427023": +Test "sin_towardzero (2)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (3) == 0.1411200080598672221007448028081102798469": +Test "sin_towardzero (3)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 -Test "sin_towardzero (8) == 0.9893582466233817778081235982452886721164": +Test "sin_towardzero (8)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 -Test "sin_upward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_upward (3)": ildouble: 1 ldouble: 1 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_upward (6)": ildouble: 1 ldouble: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh -Test "sinh (0.75) == 0.822316731935829980703661634446913849": +Test "sinh (0.75)": ildouble: 1 ldouble: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sinh_upward -Test "sinh_upward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_upward (23)": ildouble: 1 ldouble: 1 -Test "sinh_upward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_upward (24)": ildouble: 1 ldouble: 1 # tan -Test "tan (-0xc.908p-4) == -0.9997603425502441410973077452249560802034": +Test "tan (-0xc.908p-4)": ildouble: 2 ldouble: 2 -Test "tan (-0xc.90cp-4) == -0.9998823910588060302788513970802357770031": +Test "tan (-0xc.90cp-4)": ildouble: 2 ldouble: 2 -Test "tan (-0xc.90ep-4) == -0.9999434208994808753305784795924711152508": +Test "tan (-0xc.90ep-4)": ildouble: 2 ldouble: 2 -Test "tan (-0xc.90f8p-4) == -0.9999891957244072765118898375645469865764": +Test "tan (-0xc.90f8p-4)": ildouble: 2 ldouble: 2 -Test "tan (-0xc.90fcp-4) == -0.9999968250656122402859679132395522927393": +Test "tan (-0xc.90fcp-4)": ildouble: 1 ldouble: 1 -Test "tan (-0xc.90fd8p-4) == -0.9999996860835706212861509874451585282616": +Test "tan (-0xc.90fd8p-4)": ildouble: 1 ldouble: 1 -Test "tan (-0xc.90fdap-4) == -0.9999999245021033010474530133665235922808": +Test "tan (-0xc.90fdap-4)": ildouble: 1 ldouble: 1 -Test "tan (-0xc.92p-4) == -1.0004928571392300571266638743539017593717": +Test "tan (-0xc.92p-4)": ildouble: 1 ldouble: 1 -Test "tan (-0xc.9p-4) == -0.9995162902115457818029468900654150261381": +Test "tan (-0xc.9p-4)": ildouble: 1 ldouble: 1 -Test "tan (0xc.908p-4) == 0.9997603425502441410973077452249560802034": +Test "tan (0xc.908p-4)": ildouble: 2 ldouble: 2 -Test "tan (0xc.90cp-4) == 0.9998823910588060302788513970802357770031": +Test "tan (0xc.90cp-4)": ildouble: 2 ldouble: 2 -Test "tan (0xc.90ep-4) == 0.9999434208994808753305784795924711152508": +Test "tan (0xc.90ep-4)": ildouble: 2 ldouble: 2 -Test "tan (0xc.90f8p-4) == 0.9999891957244072765118898375645469865764": +Test "tan (0xc.90f8p-4)": ildouble: 2 ldouble: 2 -Test "tan (0xc.90fcp-4) == 0.9999968250656122402859679132395522927393": +Test "tan (0xc.90fcp-4)": ildouble: 1 ldouble: 1 -Test "tan (0xc.90fd8p-4) == 0.9999996860835706212861509874451585282616": +Test "tan (0xc.90fd8p-4)": ildouble: 1 ldouble: 1 -Test "tan (0xc.90fdap-4) == 0.9999999245021033010474530133665235922808": +Test "tan (0xc.90fdap-4)": ildouble: 1 ldouble: 1 -Test "tan (0xc.92p-4) == 1.0004928571392300571266638743539017593717": +Test "tan (0xc.92p-4)": ildouble: 1 ldouble: 1 -Test "tan (0xc.9p-4) == 0.9995162902115457818029468900654150261381": +Test "tan (0xc.9p-4)": ildouble: 1 ldouble: 1 -Test "tan (pi/4) == 1": +Test "tan (pi/4)": ildouble: 1 ldouble: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # tan_tonearest -Test "tan_tonearest (10) == 0.6483608274590866712591249330098086768169": +Test "tan_tonearest (10)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (4) == 1.1578212823495775831373424182673239231198": +Test "tan_tonearest (4)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (7) == 0.8714479827243187364564508896003135663222": +Test "tan_tonearest (7)": ildouble: 1 ldouble: 1 # tan_towardzero -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 -Test "tan_towardzero (6) == -0.2910061913847491570536995888681755428312": +Test "tan_towardzero (6)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (7) == 0.8714479827243187364564508896003135663222": +Test "tan_towardzero (7)": ildouble: 2 ldouble: 2 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": float: 1 ifloat: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_upward (6)": ildouble: 1 ldouble: 1 -Test "tan_upward (7) == 0.8714479827243187364564508896003135663222": +Test "tan_upward (7)": ildouble: 1 ldouble: 1 -Test "tan_upward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_upward (9)": ildouble: 1 ldouble: 1 # tanh -Test "tanh (-0.75) == -0.635148952387287319214434357312496495": +Test "tanh (-0.75)": ildouble: 1 ldouble: 1 -Test "tanh (0.75) == 0.635148952387287319214434357312496495": +Test "tanh (0.75)": ildouble: 1 ldouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # y0 -Test "y0 (0.125) == -1.38968062514384052915582277745018693": +Test "y0 (0.125)": ildouble: 1 ldouble: 1 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 -Test "y0 (0x1p-100) == -4.420092432563900590456563035154802121284e+1": +Test "y0 (0x1p-100)": ildouble: 1 ldouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -2431,138 +2431,138 @@ ildouble: 1 ldouble: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0x1.001000001p+593) == 3.927269966354206207832593635798954916263e-90": +Test "y1 (0x1.001000001p+593)": ildouble: 2 ldouble: 2 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 -Test "y1 (0x1p-20) == -6.6754421443450423911167962313100637952285e+05": +Test "y1 (0x1p-20)": ildouble: 1 ldouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 # yn -Test "yn (0, 0.125) == -1.38968062514384052915582277745018693": +Test "yn (0, 0.125)": ildouble: 1 ldouble: 1 -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/ports/sysdeps/tile/crti.S b/libc/ports/sysdeps/tile/crti.S index 9046010dc..7e8e559b9 100644 --- a/libc/ports/sysdeps/tile/crti.S +++ b/libc/ports/sysdeps/tile/crti.S @@ -95,7 +95,7 @@ _init: LD_PTR r0, r0 BEQZ r0, .Lno_weak_fn jalr r0 -#elif defined(__tilegx__) +#elif defined(__tilegx__) && !defined(NO_PLT_PCREL) /* Since we are calling from the start of the object to the PLT, call by loading the full address into a register. */ lnk r2 diff --git a/libc/ports/sysdeps/tile/dl-machine.h b/libc/ports/sysdeps/tile/dl-machine.h index 4e78bb870..05aa2d826 100644 --- a/libc/ports/sysdeps/tile/dl-machine.h +++ b/libc/ports/sysdeps/tile/dl-machine.h @@ -624,8 +624,7 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc, strtab = (const char *) D_PTR (map,l_info[DT_STRTAB]); _dl_error_printf ("%s: Symbol `%s' has different size in shared" " object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/ports/sysdeps/tile/libm-test-ulps b/libc/ports/sysdeps/tile/libm-test-ulps index eddae42c7..639e8d820 100644 --- a/libc/ports/sysdeps/tile/libm-test-ulps +++ b/libc/ports/sysdeps/tile/libm-test-ulps @@ -1,1465 +1,1450 @@ # Begin of automatic generation # atan2 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # casinh -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 # cbrt -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": -double: 1 -idouble: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i plus overflow exception": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": -double: 1 -idouble: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i plus overflow exception": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 # cexp -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i plus overflow exception": -double: 1 -idouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Real part of: clog (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Real part of: clog10 (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": float: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 ifloat: 1 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 ifloat: 2 # csin -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": -double: 1 -idouble: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i plus overflow exception": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # csinh -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": -double: 1 -idouble: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i plus overflow exception": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 # ctan_tonearest -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 2 ifloat: 2 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 idouble: 1 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 1 idouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 1 idouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 # expm1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": float: 1 ifloat: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # fma -Test "fma (-0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983) == 0x1.7ffffe00007ffp-983": +Test "fma (-0x1.fffffffffffffp-711, 0x1.fffffffffffffp-275, 0x1.fffffe00007ffp-983)": double: 1 idouble: 1 -Test "fma (0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300) == 0x1.fffffffffffffp-1": +Test "fma (0x1.0000002p+0, 0x1.ffffffcp-1, -0x1p-300)": double: 1 idouble: 1 -Test "fma (0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022) == -0x0.b22757123bbe9p-1022": +Test "fma (0x1.153d650bb9f06p-907, 0x1.2d01230d48407p-125, -0x0.b278d5acfc3cp-1022)": double: 1 idouble: 1 -Test "fma (0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022) == 0x0.0000010000003p-1022": +Test "fma (0x1.4000004p-967, 0x1p-106, 0x0.000001p-1022)": double: 1 idouble: 1 -Test "fma (0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24) == 0x1.7ff802p+13": +Test "fma (0x1.7ff8p+13, 0x1.000002p+0, 0x1.ffffp-24)": float: 1 ifloat: 1 -Test "fma (0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022) == 0x0.0000010000001p-1022": +Test "fma (0x1.7fffff8p-968, 0x1p-106, 0x0.000001p-1022)": double: 1 idouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 ifloat: 2 # lgamma -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 ifloat: 2 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # pow -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # y0 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/ports/sysdeps/tile/start.S b/libc/ports/sysdeps/tile/start.S index 99415647c..3e7ec5ccc 100644 --- a/libc/ports/sysdeps/tile/start.S +++ b/libc/ports/sysdeps/tile/start.S @@ -62,6 +62,13 @@ #include <sysdep.h> #include <arch/abi.h> +/* Just create no-ops if we don't support PC-relative PLT relocations. */ +#ifdef NO_PLT_PCREL +# define hw2_last_plt(x) 0 +# define hw1_plt(x) 0 +# define hw0_plt(x) 0 +#endif + .text .global _start .type _start,@function @@ -155,7 +162,11 @@ _start: } { ADD_PTR r4, r4, r13 - jalr r12 +# ifdef NO_PLT_PCREL + j plt(__libc_start_main) +# else + jr r12 +# endif } #else addli r0, r13, lo16(main - .Lmy_pc) diff --git a/libc/ports/sysdeps/tile/tilegx/Makefile b/libc/ports/sysdeps/tile/tilegx/Makefile index d3a0e970a..4281dd98f 100644 --- a/libc/ports/sysdeps/tile/tilegx/Makefile +++ b/libc/ports/sysdeps/tile/tilegx/Makefile @@ -1,12 +1,16 @@ include $(common-objpfx)cflags-mcmodel-large.mk +# Check for gcc to support the command-line switch, and for +# binutils to support the hwN_plt() assembly operators and relocations. $(common-objpfx)cflags-mcmodel-large.mk: $(common-objpfx)config.make mcmodel=no; \ - $(CC) -S -o /dev/null -xc /dev/null -mcmodel=large && mcmodel=yes; \ + (echo 'int main() { return getuid(); }' | \ + $(CC) -o /dev/null -xc - -mcmodel=large -fpic) && mcmodel=yes; \ echo "cflags-mcmodel-large = $$mcmodel" > $@ -ifeq ($(subdir),csu) ifeq (yes,$(cflags-mcmodel-large)) + +ifeq ($(subdir),csu) # elf-init.c is in libc_nonshared.o (the end of the shared object) but # must reach the _init symbol at the very start of the shared object. CFLAGS-elf-init.c += -mcmodel=large @@ -15,4 +19,17 @@ CFLAGS-elf-init.c += -mcmodel=large # with profiling, but calls to libc.so via the PLT at the very end. CFLAGS-gmon-start.c += -mcmodel=large endif + +else + +# Don't try to compile assembly code with hwN_plt() directives if the +# toolchain doesn't support -mcmodel=large. +ifeq ($(subdir),csu) +CPPFLAGS-start.S += -DNO_PLT_PCREL +CPPFLAGS-crti.S += -DNO_PLT_PCREL +endif +ifeq ($(subdir),nptl) +CPPFLAGS-pt-crti.S += -DNO_PLT_PCREL +endif + endif diff --git a/libc/ports/sysdeps/unix/sysv/linux/alpha/bits/siginfo.h b/libc/ports/sysdeps/unix/sysv/linux/alpha/bits/siginfo.h index 12778856f..49ca82647 100644 --- a/libc/ports/sysdeps/unix/sysv/linux/alpha/bits/siginfo.h +++ b/libc/ports/sysdeps/unix/sysv/linux/alpha/bits/siginfo.h @@ -89,6 +89,8 @@ typedef struct struct { void *si_addr; /* Faulting insn/memory ref. */ + int si_trapno; /* TRAP # which caused the signal. */ + short int si_addr_lsb; /* Valid LSB of the reported address. */ } _sigfault; /* SIGPOLL. */ @@ -121,6 +123,8 @@ typedef struct # define si_int _sifields._rt.si_sigval.sival_int # define si_ptr _sifields._rt.si_sigval.sival_ptr # define si_addr _sifields._sigfault.si_addr +# define si_trapno _sifields._sigfault.si_trapno +# define si_addr_lsb _sifields._sigfault.si_addr_lsb # define si_band _sifields._sigpoll.si_band # define si_fd _sifields._sigpoll.si_fd # define si_call_addr _sifields._sigsys._call_addr @@ -211,8 +215,12 @@ enum # define BUS_ADRALN BUS_ADRALN BUS_ADRERR, /* Non-existant physical address. */ # define BUS_ADRERR BUS_ADRERR - BUS_OBJERR /* Object specific hardware error. */ + BUS_OBJERR, /* Object specific hardware error. */ # define BUS_OBJERR BUS_OBJERR + BUS_MCEERR_AR, /* Hardware memory error: action required. */ +# define BUS_MCEERR_AR BUS_MCEERR_AR + BUS_MCEERR_AO /* Hardware memory error: action optional. */ +# define BUS_MCEERR_AO BUS_MCEERR_AO }; /* `si_code' values for SIGTRAP signal. */ diff --git a/libc/ports/sysdeps/unix/sysv/linux/ia64/bits/siginfo.h b/libc/ports/sysdeps/unix/sysv/linux/ia64/bits/siginfo.h index 7887b4554..5fa97b5d5 100644 --- a/libc/ports/sysdeps/unix/sysv/linux/ia64/bits/siginfo.h +++ b/libc/ports/sysdeps/unix/sysv/linux/ia64/bits/siginfo.h @@ -94,6 +94,7 @@ typedef struct siginfo int _si_imm; unsigned int _si_flags; unsigned long int _si_isr; + short int si_addr_lsb; /* Valid LSB of the reported address. */ } _sigfault; /* SIGPOLL. */ @@ -118,6 +119,7 @@ typedef struct siginfo # define si_int _sifields._rt.si_sigval.sival_int # define si_ptr _sifields._rt.si_sigval.sival_ptr # define si_addr _sifields._sigfault.si_addr +# define si_addr_lsb _sifields._sigfault.si_addr_lsb # define si_band _sifields._sigpoll.si_band # define si_fd _sifields._sigpoll.si_fd @@ -233,8 +235,12 @@ enum # define BUS_ADRALN BUS_ADRALN BUS_ADRERR, /* Non-existant physical address. */ # define BUS_ADRERR BUS_ADRERR - BUS_OBJERR /* Object specific hardware error. */ + BUS_OBJERR, /* Object specific hardware error. */ # define BUS_OBJERR BUS_OBJERR + BUS_MCEERR_AR, /* Hardware memory error: action required. */ +# define BUS_MCEERR_AR BUS_MCEERR_AR + BUS_MCEERR_AO /* Hardware memory error: action optional. */ +# define BUS_MCEERR_AO BUS_MCEERR_AO }; /* `si_code' values for SIGTRAP signal. */ diff --git a/libc/ports/sysdeps/unix/sysv/linux/mips/bits/siginfo.h b/libc/ports/sysdeps/unix/sysv/linux/mips/bits/siginfo.h index 56ae34c03..a9a845a61 100644 --- a/libc/ports/sysdeps/unix/sysv/linux/mips/bits/siginfo.h +++ b/libc/ports/sysdeps/unix/sysv/linux/mips/bits/siginfo.h @@ -98,6 +98,7 @@ typedef struct struct { void *si_addr; /* Faulting insn/memory ref. */ + short int si_addr_lsb; /* Valid LSB of the reported address. */ } _sigfault; /* SIGPOLL. */ @@ -122,6 +123,7 @@ typedef struct # define si_int _sifields._rt.si_sigval.sival_int # define si_ptr _sifields._rt.si_sigval.sival_ptr # define si_addr _sifields._sigfault.si_addr +# define si_addr_lsb _sifields._sigfault.si_addr_lsb # define si_band _sifields._sigpoll.si_band # define si_fd _sifields._sigpoll.si_fd @@ -209,8 +211,12 @@ enum # define BUS_ADRALN BUS_ADRALN BUS_ADRERR, /* Non-existant physical address. */ # define BUS_ADRERR BUS_ADRERR - BUS_OBJERR /* Object specific hardware error. */ + BUS_OBJERR, /* Object specific hardware error. */ # define BUS_OBJERR BUS_OBJERR + BUS_MCEERR_AR, /* Hardware memory error: action required. */ +# define BUS_MCEERR_AR BUS_MCEERR_AR + BUS_MCEERR_AO /* Hardware memory error: action optional. */ +# define BUS_MCEERR_AO BUS_MCEERR_AO }; /* `si_code' values for SIGTRAP signal. */ diff --git a/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/n32/sysdep.h b/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/n32/sysdep.h index 452c2c70e..b2a9a9579 100644 --- a/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/n32/sysdep.h +++ b/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/n32/sysdep.h @@ -39,9 +39,7 @@ /* We don't want the label for the error handler to be visible in the symbol table when we define it here. */ -#ifdef __PIC__ # define SYSCALL_ERROR_LABEL 99b -#endif #else /* ! __ASSEMBLER__ */ diff --git a/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/n64/sysdep.h b/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/n64/sysdep.h index d16ed6941..844a7e880 100644 --- a/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/n64/sysdep.h +++ b/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/n64/sysdep.h @@ -39,9 +39,7 @@ /* We don't want the label for the error handler to be visible in the symbol table when we define it here. */ -#ifdef __PIC__ # define SYSCALL_ERROR_LABEL 99b -#endif #else /* ! __ASSEMBLER__ */ diff --git a/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/nptl/sysdep-cancel.h b/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/nptl/sysdep-cancel.h index 656522566..157cc3825 100644 --- a/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/nptl/sysdep-cancel.h +++ b/libc/ports/sysdeps/unix/sysv/linux/mips/mips64/nptl/sysdep-cancel.h @@ -101,13 +101,64 @@ cfi_same_value (gp); \ RESTORESTK; \ L(pseudo_end): - +#else +# undef PSEUDO +# define PSEUDO(name, syscall_name, args) \ + .align 2; \ + L(pseudo_start): \ + cfi_startproc; \ + cfi_adjust_cfa_offset (STKSPACE); \ + 99: RESTORESTK; \ + j __syscall_error; \ + .type __##syscall_name##_nocancel, @function; \ + .globl __##syscall_name##_nocancel; \ + __##syscall_name##_nocancel: \ + SAVESTK; \ + li v0, SYS_ify(syscall_name); \ + syscall; \ + bne a3, zero, SYSCALL_ERROR_LABEL; \ + RESTORESTK; \ + ret; \ + cfi_endproc; \ + .size __##syscall_name##_nocancel,.-__##syscall_name##_nocancel; \ + ENTRY (name) \ + SAVESTK; \ + SINGLE_THREAD_P(v1); \ + bne zero, v1, L(pseudo_cancel); \ + .set noreorder; \ + li v0, SYS_ify(syscall_name); \ + syscall; \ + .set reorder; \ + bne a3, zero, SYSCALL_ERROR_LABEL; \ + RESTORESTK; \ + ret; \ + L(pseudo_cancel): \ + cfi_adjust_cfa_offset (STKSPACE); \ + REG_S ra, STKOFF_RA(sp); \ + cfi_rel_offset (ra, STKOFF_RA); \ + PUSHARGS_##args; /* save syscall args */ \ + CENABLE; \ + REG_S v0, STKOFF_SVMSK(sp); /* save mask */ \ + POPARGS_##args; /* restore syscall args */ \ + .set noreorder; \ + li v0, SYS_ify (syscall_name); \ + syscall; \ + .set reorder; \ + REG_S v0, STKOFF_SC_V0(sp); /* save syscall result */ \ + REG_S a3, STKOFF_SC_ERR(sp); /* save syscall error flag */ \ + REG_L a0, STKOFF_SVMSK(sp); /* pass mask as arg1 */ \ + CDISABLE; \ + REG_L a3, STKOFF_SC_ERR(sp); /* restore syscall error flag */ \ + REG_L ra, STKOFF_RA(sp); /* restore return address */ \ + REG_L v0, STKOFF_SC_V0(sp); /* restore syscall result */ \ + bne a3, zero, SYSCALL_ERROR_LABEL; \ + RESTORESTK; \ + L(pseudo_end): +#endif # undef PSEUDO_END # define PSEUDO_END(sym) cfi_endproc; .end sym; .size sym,.-sym -#endif - # define PUSHARGS_0 /* nothing to do */ # define PUSHARGS_1 PUSHARGS_0 REG_S a0, STKOFF_A0(sp); cfi_rel_offset (a0, STKOFF_A0); # define PUSHARGS_2 PUSHARGS_1 REG_S a1, STKOFF_A1(sp); cfi_rel_offset (a1, STKOFF_A1); @@ -126,7 +177,11 @@ /* Save an even number of slots. Should be 0 if an even number of slots are used below, or SZREG if an odd number are used. */ -# define STK_PAD SZREG +# ifdef __PIC__ +# define STK_PAD SZREG +# else +# define STK_PAD 0 +# endif /* Place values that we are more likely to use later in this sequence, i.e. closer to the SP at function entry. If you do that, the are more @@ -141,21 +196,32 @@ # define STKOFF_SC_V0 (STKOFF_RA + SZREG) /* Used if MT. */ # define STKOFF_SC_ERR (STKOFF_SC_V0 + SZREG) /* Used if MT. */ # define STKOFF_SVMSK (STKOFF_SC_ERR + SZREG) /* Used if MT. */ -# define STKOFF_GP (STKOFF_SVMSK + SZREG) /* Always used. */ -# define STKSPACE (STKOFF_GP + SZREG) +# ifdef __PIC__ +# define STKOFF_GP (STKOFF_SVMSK + SZREG) /* Always used. */ +# define STKSPACE (STKOFF_GP + SZREG) +# else +# define STKSPACE (STKOFF_SVMSK + SZREG) +# endif + # define SAVESTK PTR_SUBU sp, STKSPACE; cfi_adjust_cfa_offset(STKSPACE) # define RESTORESTK PTR_ADDU sp, STKSPACE; cfi_adjust_cfa_offset(-STKSPACE) +# ifdef __PIC__ +# define PSEUDO_JMP(sym) PTR_LA t9, sym; jalr t9 +# else +# define PSEUDO_JMP(sym) jal sym +# endif + # ifdef IS_IN_libpthread -# define CENABLE PTR_LA t9, __pthread_enable_asynccancel; jalr t9 -# define CDISABLE PTR_LA t9, __pthread_disable_asynccancel; jalr t9 +# define CENABLE PSEUDO_JMP (__pthread_enable_asynccancel) +# define CDISABLE PSEUDO_JMP (__pthread_disable_asynccancel) # elif defined IS_IN_librt -# define CENABLE PTR_LA t9, __librt_enable_asynccancel; jalr t9 -# define CDISABLE PTR_LA t9, __librt_disable_asynccancel; jalr t9 +# define CENABLE PSEUDO_JMP (__librt_enable_asynccancel) +# define CDISABLE PSEUDO_JMP (__librt_disable_asynccancel) # else -# define CENABLE PTR_LA t9, __libc_enable_asynccancel; jalr t9 -# define CDISABLE PTR_LA t9, __libc_disable_asynccancel; jalr t9 +# define CENABLE PSEUDO_JMP (__libc_enable_asynccancel) +# define CDISABLE PSEUDO_JMP (__libc_disable_asynccancel) # endif # ifndef __ASSEMBLER__ diff --git a/libc/ports/sysdeps/unix/sysv/linux/tile/bits/siginfo.h b/libc/ports/sysdeps/unix/sysv/linux/tile/bits/siginfo.h index 4ad1a5db6..7b40f3db0 100644 --- a/libc/ports/sysdeps/unix/sysv/linux/tile/bits/siginfo.h +++ b/libc/ports/sysdeps/unix/sysv/linux/tile/bits/siginfo.h @@ -95,7 +95,8 @@ typedef struct struct { void *si_addr; /* Faulting insn/memory ref. */ - int si_trapno; /* TRAP # which caused the signal */ + int si_trapno; /* TRAP # which caused the signal. */ + short int si_addr_lsb; /* Valid LSB of the reported address. */ } _sigfault; /* SIGPOLL. */ @@ -129,6 +130,7 @@ typedef struct # define si_ptr _sifields._rt.si_sigval.sival_ptr # define si_addr _sifields._sigfault.si_addr # define si_trapno _sifields._sigfault.si_trapno +# define si_addr_lsb _sifields._sigfault.si_addr_lsb # define si_band _sifields._sigpoll.si_band # define si_fd _sifields._sigpoll.si_fd # define si_call_addr _sifields._sigsys._call_addr @@ -223,8 +225,12 @@ enum # define BUS_ADRALN BUS_ADRALN BUS_ADRERR, /* Non-existant physical address. */ # define BUS_ADRERR BUS_ADRERR - BUS_OBJERR /* Object specific hardware error. */ + BUS_OBJERR, /* Object specific hardware error. */ # define BUS_OBJERR BUS_OBJERR + BUS_MCEERR_AR, /* Hardware memory error: action required. */ +# define BUS_MCEERR_AR BUS_MCEERR_AR + BUS_MCEERR_AO /* Hardware memory error: action optional. */ +# define BUS_MCEERR_AO BUS_MCEERR_AO }; /* `si_code' values for SIGTRAP signal. */ diff --git a/libc/posix/Makefile b/libc/posix/Makefile index b899322df..e8840b3a4 100644 --- a/libc/posix/Makefile +++ b/libc/posix/Makefile @@ -96,7 +96,7 @@ tests := tstgetopt testfnm runtests \ tst-fnmatch2 tst-cpucount tst-cpuset \ bug-getopt1 bug-getopt2 bug-getopt3 bug-getopt4 \ bug-getopt5 tst-getopt_long1 bug-regex34 bug-regex35 \ - tst-pathconf + tst-pathconf tst-getaddrinfo4 tests-$(OPTION_EGLIBC_LOCALE_CODE) \ += tst-fnmatch tst-regexloc bug-regex1 bug-regex5 \ bug-regex23 bug-regex25 bug-regex32 bug-regex33 diff --git a/libc/posix/tst-getaddrinfo4.c b/libc/posix/tst-getaddrinfo4.c new file mode 100644 index 000000000..10850cdc1 --- /dev/null +++ b/libc/posix/tst-getaddrinfo4.c @@ -0,0 +1,67 @@ +/* Test getaddrinfo return value, [BZ #15339]. + Copyright (C) 2013 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +#include <string.h> +#include <stdio.h> +#include <errno.h> +#include <netdb.h> + +static int +try (const char *service, int family, int flags) +{ + struct addrinfo hints, *h, *ai; + int res; + + memset (&hints, 0, sizeof hints); + hints.ai_family = family; + hints.ai_flags = flags; + + errno = 0; + h = (family || flags) ? &hints : NULL; + res = getaddrinfo ("example.net", service, h, &ai); + switch (res) + { + case 0: + case EAI_AGAIN: + case EAI_NONAME: + printf ("SUCCESS getaddrinfo(service=%s, family=%d, flags=%d): %s: %m\n", + service ?: "NULL", family, flags, gai_strerror (res)); + return 0; + } + printf ("FAIL getaddrinfo(service=%s, family=%d, flags=%d): %s: %m\n", + service ?: "NULL", family, flags, gai_strerror (res)); + return 1; +} + +static int +do_test (void) +{ + int err = 0; + err |= try (NULL, 0, 0); + err |= try (NULL, AF_UNSPEC, AI_ADDRCONFIG); + err |= try (NULL, AF_INET, 0); + err |= try (NULL, AF_INET6, 0); + err |= try ("http", 0, 0); + err |= try ("http", AF_UNSPEC, AI_ADDRCONFIG); + err |= try ("http", AF_INET, 0); + err |= try ("http", AF_INET6, 0); + return err; +} + +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" diff --git a/libc/resolv/Makefile b/libc/resolv/Makefile index edc4b0d71..8da047014 100644 --- a/libc/resolv/Makefile +++ b/libc/resolv/Makefile @@ -86,23 +86,11 @@ CFLAGS-res_hconf.c = -fexceptions # The BIND code elicits some harmless warnings. +cflags += -Wno-strict-prototypes -Wno-write-strings -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -$(objpfx)libresolv.so: $(common-objpfx)libc.so $(common-objpfx)libc_nonshared.a -# Some hosts need '__stack_chk_guard', so pull in the definition from -# ld.so if required. -ifeq (yes,$(have-ssp)) -LDLIBS-resolv.so += $(as-needed) $(elfobjdir)/ld.so $(no-as-needed) -endif - # The DNS NSS modules needs the resolver. -$(objpfx)libnss_dns.so: $(objpfx)libresolv.so $(common-objpfx)libc.so \ - $(common-objpfx)libc_nonshared.a +$(objpfx)libnss_dns.so: $(objpfx)libresolv.so # The asynchronous name lookup code needs the thread library. -$(objpfx)libanl.so: $(common-objpfx)libc.so $(common-objpfx)libc_nonshared.a \ - $(shared-thread-library) +$(objpfx)libanl.so: $(shared-thread-library) $(objpfx)ga_test: $(objpfx)libanl.so $(shared-thread-library) diff --git a/libc/rt/Makefile b/libc/rt/Makefile index ef356d0aa..b1392f2e0 100644 --- a/libc/rt/Makefile +++ b/libc/rt/Makefile @@ -64,12 +64,7 @@ CFLAGS-librt-cancellation.c = -fasynchronous-unwind-tables LDFLAGS-rt.so = -Wl,--enable-new-dtags,-z,nodelete -# Depend on libc.so so a DT_NEEDED is generated in the shared objects. -# This ensures they will load libc.so for needed symbols if loaded by -# a statically-linked program that hasn't already loaded it. -$(objpfx)librt.so: $(common-objpfx)libc.so $(common-objpfx)libc_nonshared.a \ - $(shared-thread-library) \ - $(elfobjdir)/ld.so +$(objpfx)librt.so: $(shared-thread-library) ifeq (yes,$(build-shared)) $(addprefix $(objpfx),$(tests)): $(objpfx)librt.so $(shared-thread-library) diff --git a/libc/setjmp/Makefile b/libc/setjmp/Makefile index 612433354..913359cf7 100644 --- a/libc/setjmp/Makefile +++ b/libc/setjmp/Makefile @@ -25,7 +25,8 @@ headers := setjmp.h bits/setjmp.h bits/setjmp2.h routines := setjmp sigjmp bsd-setjmp bsd-_setjmp \ longjmp __longjmp jmp-unwind -tests := tst-setjmp jmpbug bug269-setjmp tst-setjmp-fp +tests := tst-setjmp jmpbug bug269-setjmp tst-setjmp-fp \ + tst-sigsetjmp include ../Rules diff --git a/libc/setjmp/tst-sigsetjmp.c b/libc/setjmp/tst-sigsetjmp.c new file mode 100644 index 000000000..467c26a96 --- /dev/null +++ b/libc/setjmp/tst-sigsetjmp.c @@ -0,0 +1,44 @@ +/* Copyright (C) 2013 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +/* Test case for BZ #15493 */ + +#include <stdlib.h> +#include <signal.h> +#include <setjmp.h> + +static int +do_test (void) +{ + sigjmp_buf sj; + sigset_t m; + + sigemptyset (&m); + sigprocmask (SIG_SETMASK, &m, NULL); + if (sigsetjmp (sj, 0) == 0) + { + sigaddset (&m, SIGUSR1); + sigprocmask (SIG_SETMASK, &m, NULL); + siglongjmp (sj, 1); + return EXIT_FAILURE; + } + sigprocmask (SIG_SETMASK, NULL, &m); + return sigismember (&m, SIGUSR1) ? EXIT_SUCCESS : EXIT_FAILURE; +} + +#define TEST_FUNCTION do_test () +#include "../test-skeleton.c" diff --git a/libc/stdio-common/bug26.c b/libc/stdio-common/bug26.c index a4c6bce93..cc54b9641 100644 --- a/libc/stdio-common/bug26.c +++ b/libc/stdio-common/bug26.c @@ -28,8 +28,9 @@ main (void) char s[] = "+.e"; f = fmemopen (s, strlen (s), "r"); - /* This should fail to parse a float and leave 'e' in the input. */ - lost |= (fscanf (f, "%f", &d) != 0); + /* This should fail to parse a floating-point number, and leave 'e' in the + input. */ + lost |= (fscanf (f, "%lf", &d) != 0); c = fgetc (f); lost |= c != 'e'; puts (lost ? "Test FAILED!" : "Test succeeded."); diff --git a/libc/stdlib/Makefile b/libc/stdlib/Makefile index 5796245eb..89ce992c9 100644 --- a/libc/stdlib/Makefile +++ b/libc/stdlib/Makefile @@ -158,7 +158,7 @@ $(objpfx)tst-fmtmsg.out: tst-fmtmsg.sh $(objpfx)tst-fmtmsg $(objpfx)tst-putenv: $(objpfx)tst-putenvmod.so LDFLAGS-tst-putenv = $(no-as-needed) -$(objpfx)tst-putenvmod.so: $(objpfx)tst-putenvmod.os +$(objpfx)tst-putenvmod.so: $(objpfx)tst-putenvmod.os $(link-libc-deps) $(build-module) CFLAGS-tst-putenvmod.c = -DNOT_IN_libc=1 diff --git a/libc/sysdeps/generic/ldsodefs.h b/libc/sysdeps/generic/ldsodefs.h index 3289afe1f..1d47f8819 100644 --- a/libc/sysdeps/generic/ldsodefs.h +++ b/libc/sysdeps/generic/ldsodefs.h @@ -128,6 +128,11 @@ typedef struct link_map *lookup_t; | ((PROT_WRITE | PROT_EXEC) << (PF_W | PF_X) * 4) \ | ((PROT_READ | PROT_WRITE | PROT_EXEC) << ((PF_R | PF_W | PF_X) * 4))) +/* The filename itself, or the main program name, if available. */ +#define DSO_FILENAME(name) ((name)[0] ? (name) \ + : (rtld_progname ?: "<main program>")) + +#define RTLD_PROGNAME (rtld_progname ?: "<program name unknown>") /* For the version handling we need an array with only names and their hash values. */ diff --git a/libc/sysdeps/gnu/errlist.c b/libc/sysdeps/gnu/errlist.c index e3d2faf56..bbd45f283 100644 --- a/libc/sysdeps/gnu/errlist.c +++ b/libc/sysdeps/gnu/errlist.c @@ -780,11 +780,12 @@ TRANS The user's disk quota was exceeded. */ #endif #ifdef ESTALE /* -TRANS Stale NFS file handle. This indicates an internal confusion in the NFS -TRANS system which is due to file system rearrangements on the server host. -TRANS Repairing this condition usually requires unmounting and remounting -TRANS the NFS file system on the local host. */ - [ERR_REMAP (ESTALE)] = N_("Stale NFS file handle"), +TRANS Stale file handle. This indicates an internal confusion in the +TRANS file system which is due to file system rearrangements on the server host +TRANS for NFS file systems or corruption in other file systems. +TRANS Repairing this condition usually requires unmounting, possibly repairing +TRANS and remounting the file system. */ + [ERR_REMAP (ESTALE)] = N_("Stale file handle"), # if ESTALE > ERR_MAX # undef ERR_MAX # define ERR_MAX ESTALE diff --git a/libc/sysdeps/i386/dl-machine.h b/libc/sysdeps/i386/dl-machine.h index 0b4c46736..b6fc8051e 100644 --- a/libc/sysdeps/i386/dl-machine.h +++ b/libc/sysdeps/i386/dl-machine.h @@ -464,8 +464,7 @@ elf_machine_rel (struct link_map *map, const Elf32_Rel *reloc, strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); @@ -610,8 +609,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc, strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/sysdeps/i386/fpu/Makefile b/libc/sysdeps/i386/fpu/Makefile deleted file mode 100644 index 1309b64c1..000000000 --- a/libc/sysdeps/i386/fpu/Makefile +++ /dev/null @@ -1,3 +0,0 @@ -ifeq ($(subdir),math) -$(objpfx)libm.so: $(elfobjdir)/ld.so -endif diff --git a/libc/sysdeps/i386/fpu/libm-test-ulps b/libc/sysdeps/i386/fpu/libm-test-ulps index 3b8f2af08..aff617c35 100644 --- a/libc/sysdeps/i386/fpu/libm-test-ulps +++ b/libc/sysdeps/i386/fpu/libm-test-ulps @@ -1,4526 +1,4526 @@ # Begin of automatic generation # acos -Test "acos (0.75) == 0.722734247813415611178377352641333362": +Test "acos (0.75)": ildouble: 1 ldouble: 1 # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # acos_upward -Test "acos_upward (-0) == pi/2": +Test "acos_upward (-0)": double: 1 idouble: 1 -Test "acos_upward (-0.5) == M_PI_6l*4.0": +Test "acos_upward (-0.5)": ildouble: 1 ldouble: 1 -Test "acos_upward (-1) == pi": +Test "acos_upward (-1)": double: 1 idouble: 1 -Test "acos_upward (0) == pi/2": +Test "acos_upward (0)": double: 1 idouble: 1 -Test "acos_upward (0.5) == M_PI_6l*2.0": +Test "acos_upward (0.5)": ildouble: 1 ldouble: 1 # asin -Test "asin (-0.5) == -pi/6": +Test "asin (-0.5)": ildouble: 1 ldouble: 1 -Test "asin (-0x0.ffffffff8p0) == -1.5707810680058339712015850710748035974710": +Test "asin (-0x0.ffffffff8p0)": ildouble: 1 ldouble: 1 -Test "asin (-0x0.ffffffffffffffffp0) == -1.5707963264656243652399620683025688888978": +Test "asin (-0x0.ffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (-0x0.ffffffffffffp0) == -1.5707962425011995974432331617542781977068": +Test "asin (-0x0.ffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (-0x0.ffffffp0) == -1.5704510598101804156437184421571127056013": +Test "asin (-0x0.ffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (-1.0) == -pi/2": +Test "asin (-1.0)": ildouble: 1 ldouble: 1 -Test "asin (0.5) == pi/6": +Test "asin (0.5)": ildouble: 1 ldouble: 1 -Test "asin (0.75) == 0.848062078981481008052944338998418080": +Test "asin (0.75)": ildouble: 1 ldouble: 1 -Test "asin (0x0.ffffffff8p0) == 1.5707810680058339712015850710748035974710": +Test "asin (0x0.ffffffff8p0)": ildouble: 1 ldouble: 1 -Test "asin (0x0.ffffffffffffffffp0) == 1.5707963264656243652399620683025688888978": +Test "asin (0x0.ffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (0x0.ffffffffffffp0) == 1.5707962425011995974432331617542781977068": +Test "asin (0x0.ffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (0x0.ffffffp0) == 1.5704510598101804156437184421571127056013": +Test "asin (0x0.ffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (1.0) == pi/2": +Test "asin (1.0)": ildouble: 1 ldouble: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": ildouble: 1 ldouble: 1 -Test "asin_downward (-1.0) == -pi/2": +Test "asin_downward (-1.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # asin_tonearest -Test "asin_tonearest (-0.5) == -pi/6": +Test "asin_tonearest (-0.5)": ildouble: 1 ldouble: 1 -Test "asin_tonearest (-1.0) == -pi/2": +Test "asin_tonearest (-1.0)": ildouble: 1 ldouble: 1 -Test "asin_tonearest (0.5) == pi/6": +Test "asin_tonearest (0.5)": ildouble: 1 ldouble: 1 -Test "asin_tonearest (1.0) == pi/2": +Test "asin_tonearest (1.0)": ildouble: 1 ldouble: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # asin_upward -Test "asin_upward (-0.5) == -pi/6": +Test "asin_upward (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "asin_upward (0.5) == pi/6": +Test "asin_upward (0.5)": ildouble: 1 ldouble: 1 -Test "asin_upward (1.0) == pi/2": +Test "asin_upward (1.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": ildouble: 2 ldouble: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x1p-23 i) == 1.570796326794896619231321691639751442099 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (-0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x1p-23 i) == 1.570796326794896619231321691639751442099 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (-0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (-0.25 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (-0.25 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-1025 i) == 2.094395102393195492308428922186335256131 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-16385 i) == 2.094395102393195492308428922186335256131 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i) == 2.094395102393190022547898764614298351924 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-52 i) == 2.094395102393195492308428922186316279087 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-1025 i) == 2.094395102393195492308428922186335256131 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-16385 i) == 2.094395102393195492308428922186335256131 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i) == 2.094395102393190022547898764614298351924 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-52 i) == 2.094395102393195492308428922186316279087 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 3.141592634635223399311902261000251614142 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 3.141592634635223399311902261000251614142 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 3.141592653260520984471283759942320330996 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == 3.141592653170952461345846619605307690007 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 3.141592653260520984471283759942320330996 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == 3.141592653170952461345846619605307690007 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i) == 3.141153467203602189751698864505105063797 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i) == 3.141153467203602189751698864505105063797 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000000002p0 + 0x1p-63 i) == 3.141592653377875508152537040020250564229 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0x1.0000000000000002p0 - 0x1p-63 i) == 3.141592653377875508152537040020250564229 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0.0 i) == 3.141592653589793238462643383279502884197 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1p-52 i) == 3.141592643999491532482601997450598791535 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0.0 i) == 3.141592653589793238462643383279502884197 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1p-52 i) == 3.141592643999491532482601997450598791535 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i) == 1.572134236154454360143880041170803681211 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i) == 1.572134236154454360143880041170803681211 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691640832196834 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691640832196834 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442101 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0x1p-23 i) == 1.570796326794896619231321691639751442101 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442101 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442101 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0x1p-23 i) == 1.570796326794896619231321691639751442101 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442101 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i) == 1.570796328070826603447840231892468927106 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i) == 1.570796328070826603447840231892468927106 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i) == 1.570796326794896619231321691639773491431 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i) == 1.570796326794896619231321691639773491431 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751614359 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751614359 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i) == 1.570796433418926613232299739606181733819 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i) == 1.570796433418926613232299739606181733819 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i) == 1.570796326794896817834053951421591208280 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i) == 1.570796326794896817834053951421591208280 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i) == 1.570796326794896619328295682000973043547 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619307986362473920146173 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i) == 1.570796326794896619328295682000973043547 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619307986362473920146173 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 + 0.5 i) == 2.466703808003786858297978415967328452322 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 + 0.5 i) == 2.466703808003786858297978415967328452322 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1.fp-30 i) == 3.141550174918818561961484385371624132331 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 - 0.5 i) == 2.466703808003786858297978415967328452322 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 - 0.5 i) == 2.466703808003786858297978415967328452322 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1.fp-30 i) == 3.141550174918818561961484385371624132331 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + 0x1.fp-129 i) == 3.141592653589793238462643383279502884195 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + 0x1.fp-16385 i) == 3.141592653589793238462643383279502884197 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0 i) == pi + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0x1.fp-129 i) == 3.141592653589793238462643383279502884195 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0x1.fp-16385 i) == 3.141592653589793238462643383279502884197 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x1p-23 i) == 1.570796326794896619231321691639751442099 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x1p-23 i) == 1.570796326794896619231321691639751442099 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.25 + 1.0 i) == 1.394493894017929688812643125003661339452 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (0.25 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.25 - 1.0 i) == 1.394493894017929688812643125003661339452 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (0.25 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 - 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-16385 i) == 1.047197551196597746154214461093167628066 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-105 i) == 1.047197551196597746154214461093167628066 - 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-112 i) == 1.047197551196597746154214461093167628066 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-23 i) == 1.047197551196603215914744618665204532273 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (0.5 + 0x1p-52 i) == 1.047197551196597746154214461093186605110 - 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-52 i) == 1.047197551196597746154214461093186605110 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-63 i) == 1.047197551196597746154214461093167628070 - 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 + 0x1p-63 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 1.0 i) == 1.221357263937683325603909865564381489366 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 + 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-16385 i) == 1.047197551196597746154214461093167628066 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-105 i) == 1.047197551196597746154214461093167628066 + 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-112 i) == 1.047197551196597746154214461093167628066 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-23 i) == 1.047197551196603215914744618665204532273 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (0.5 - 0x1p-52 i) == 1.047197551196597746154214461093186605110 + 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-52 i) == 1.047197551196597746154214461093186605110 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-63 i) == 1.047197551196597746154214461093167628070 + 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 - 0x1p-63 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 1.0 i) == 1.221357263937683325603909865564381489366 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: cacos (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 - 1.171456840272878582596796205397918831268e-8 i": +Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 + 1.171456840272878582596796205397918831268e-8 i": +Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 3.292722539913596233371825532007990724506e-10 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 - 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 3.292722539913596233371825532007990724506e-10 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 + 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 - 5.116146586219826555037807251857670783420e-10 i": +Test "Real part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 + 5.116146586219826555037807251857670783420e-10 i": +Test "Real part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0.0 i) == 0.0 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1.fp-1025 i) == 2.557178503953494342609835913586108008322e-301 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 - 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0.0 i) == 0.0 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1.fp-1025 i) == 2.557178503953494342609835913586108008322e-301 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 + 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i) == 1.569458417435338878318763342108699202986 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i) == 1.569458417435338878318763342108699202986 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691638670687364 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691638670687364 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442096 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442097 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0x1p-23 i) == 1.570796326794896619231321691639751442096 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442097 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442097 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442096 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442097 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0x1p-23 i) == 1.570796326794896619231321691639751442096 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442097 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442097 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i) == 1.570796325518966635014803151387033957091 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i) == 1.570796325518966635014803151387033957091 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 - 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 - 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1p-105 + 0.5 i) == 1.570796326794896619231321691639729392766 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-105 - 0.5 i) == 1.570796326794896619231321691639729392766 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751269838 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751269838 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0.5 i) == 1.570796220170866625230343643673321150378 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0.5 i) == 1.570796220170866625230343643673321150378 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 + 0.5 i) == 1.570796326794896420628589431857911675917 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 - 0.5 i) == 1.570796326794896420628589431857911675917 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0.5 i) == 1.570796326794896619134347701278529840650 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619154657020805582738025 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0.5 i) == 1.570796326794896619134347701278529840650 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619154657020805582738025 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 + 0x1.fp-10 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 - 4.247867098745151888768727039216644758847e-5 i": +Test "Real part of: cacos (1.0 + 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (1.0 + 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 - 0x1.fp-10 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 + 4.247867098745151888768727039216644758847e-5 i": +Test "Real part of: cacos (1.0 - 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (1.0 - 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + 0x1.fp-1025 i) == 4.819934639999230680322935210539402497827e-309 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + 0x1.fp-129 i) == 2.546345110742945032959687790021055102355e-39 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + 0x1.fp-16385 i) == 7.282957076134209141226696333885150260319e-4933 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0 i) == +0 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0x1.fp-1025 i) == 4.819934639999230680322935210539402497827e-309 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0x1.fp-129 i) == 2.546345110742945032959687790021055102355e-39 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0x1.fp-16385 i) == 7.282957076134209141226696333885150260319e-4933 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Real part of: cacosh (-0.25 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Real part of: cacosh (-0.25 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 2.094395102393195492308428922186316279087 i": +Test "Real part of: cacosh (-0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 2.094395102393195492308428922186316279087 i": +Test "Real part of: cacosh (-0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 + 3.141592653260520984471283759942320330996 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 3.141592653170952461345846619605307690007 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 - 3.141592653260520984471283759942320330996 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 3.141592653170952461345846619605307690007 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 3.141592653377875508152537040020250564229 i": +Test "Real part of: cacosh (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacosh (-0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 3.141592653377875508152537040020250564229 i": +Test "Real part of: cacosh (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacosh (-0x1.0000000000001p0 + 0.0 i) == 2.107342425544701550354780375182800088393e-8 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 3.141592643999491532482601997450598791535 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 - 0.0 i) == 2.107342425544701550354780375182800088393e-8 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 3.141592643999491532482601997450598791535 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 + 1.570796326794896619307986362473920146173 i": +Test "Real part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 - 1.570796326794896619307986362473920146173 i": +Test "Real part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 2.466703808003786858297978415967328452322 i": +Test "Imaginary part of: cacosh (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 + 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 + 3.141550174918818561961484385371624132331 i": +Test "Real part of: cacosh (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 2.466703808003786858297978415967328452322 i": +Test "Imaginary part of: cacosh (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 - 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 - 3.141550174918818561961484385371624132331 i": +Test "Real part of: cacosh (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 + 3.141592653589793238462643383279502884195 i": +Test "Real part of: cacosh (-1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 - 3.141592653589793238462643383279502884195 i": +Test "Real part of: cacosh (-1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.394493894017929688812643125003661339452 i": +Test "Real part of: cacosh (0.25 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.394493894017929688812643125003661339452 i": +Test "Real part of: cacosh (0.25 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + +0 i) == +0 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 1.047197551196597746154214461093186605110 i": +Test "Real part of: cacosh (0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 1.047197551196597746154214461093186605110 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 + 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0 i) == +0 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 1.047197551196597746154214461093186605110 i": +Test "Real part of: cacosh (0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 1.047197551196597746154214461093186605110 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 - 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.75 + 1.25 i) == 1.13239363160530819522266333696834467 + 1.11752014915610270578240049553777969 i": +Test "Real part of: cacosh (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 1.895456983915074112227925127005564372844e-8 i": +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 1.895456983915074112227925127005564372844e-8 i": +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 + 3.292722539913596233371825532007990724506e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 4.188407771167967636741951941902992986043e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 4.188407771167967636741951941902992986043e-10 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 - 3.292722539913596233371825532007990724506e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 4.188407771167967636741951941902992986043e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 4.188407771167967636741951941902992986043e-10 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 2.119177303101063432592523199680782317447e-10 i": +Test "Real part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 2.119177303101063432592523199680782317447e-10 i": +Test "Imaginary part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 2.119177303101063432592523199680782317447e-10 i": +Test "Real part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 2.119177303101063432592523199680782317447e-10 i": +Test "Imaginary part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 + 0.0 i) == 2.107342425544701550354780375182800088393e-8 + 0.0 i": +Test "Real part of: cacosh (0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 + 2.557178503953494342609835913586108008322e-301 i": +Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 9.590301705980041385828904092662391018164e-9 i": +Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 - 0.0 i) == 2.107342425544701550354780375182800088393e-8 - 0.0 i": +Test "Real part of: cacosh (0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 - 2.557178503953494342609835913586108008322e-301 i": +Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 9.590301705980041385828904092662391018164e-9 i": +Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 + 1.570796326794896619154657020805582738025 i": +Test "Real part of: cacosh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 - 1.570796326794896619154657020805582738025 i": +Test "Real part of: cacosh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 + 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 + 4.247867097467650115899790787875186617316e-5 i": +Test "Real part of: cacosh (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 + 4.247867097467650115899790787875186617316e-5 i": +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 - 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 - 4.247867097467650115899790787875186617316e-5 i": +Test "Real part of: cacosh (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 - 4.247867097467650115899790787875186617316e-5 i": +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 + 4.819934639999230680322935210539402497827e-309 i": +Test "Real part of: cacosh (1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: cacosh (1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 + 7.282957076134209141226696333885150260319e-4933 i": +Test "Real part of: cacosh (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 - 4.819934639999230680322935210539402497827e-309 i": +Test "Real part of: cacosh (1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: cacosh (1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 - 7.282957076134209141226696333885150260319e-4933 i": +Test "Real part of: cacosh (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffp0 i) == -0.0 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x1.000002p0 i) == -0.0 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x1p-23 i) == -0.0 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (-0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffp0 i) == -0.0 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x1.000002p0 i) == -0.0 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x1p-23 i) == -0.0 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (-0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.25 + 1.0 i) == -1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (-0.25 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.25 - 1.0 i) == -1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (-0.25 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-1025 i) == -5.235987755982988730771072305465838140329e-1 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-16385 i) == -5.235987755982988730771072305465838140329e-1 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (-0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-52 i) == -5.235987755982988730771072305465648369889e-1 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + 1.0 i) == -3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (-0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 1.0 i) == -3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-1025 i) == -5.235987755982988730771072305465838140329e-1 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-16385 i) == -5.235987755982988730771072305465838140329e-1 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (-0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-52 i) == -5.235987755982988730771072305465648369889e-1 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 1.0 i) == -3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (-0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 1.0 i) == -3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i) == -1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i) == -1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == -1.570796326465624365239962068302568888898 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -1.570796326376055842114524927965556247908 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == -1.570796326465624365239962068302568888898 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -1.570796326376055842114524927965556247908 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i) == -1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i) == -1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000000002p0 + 0x1p-63 i) == -1.570796326582978888921215348380499122131 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1.0000000000000002p0 - 0x1p-63 i) == -1.570796326582978888921215348380499122131 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0.0 i) == -1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1p-52 i) == -1.570796317204594913251280305810847349436 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0.0 i) == -1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1p-52 i) == -1.570796317204594913251280305810847349436 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i) == -1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i) == -1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i) == -1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i) == -1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i) == -3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i) == -2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i) == -3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i) == -2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i) == -2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-129 + 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0x1p-23 i) == -2.846900380897707329917933005874691056564e-39 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i) == -2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i) == -1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i) == -2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-129 - 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0x1p-23 i) == -2.846900380897707329917933005874691056564e-39 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i) == -2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i) == -1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == -5.757683115456107044287327268904964422212e-4933 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == -5.757683115456107044287327268904964422212e-4933 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (-0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (-0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-105 + 0.5 i) == -2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-105 - 0.5 i) == -2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-112 + 0.5 i) == -1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-112 - 0.5 i) == -1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-52 + 0.5 i) == -1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-52 + 0x1.0000000000001p0 i) == -1.570092458683774885078102529858632363236e-16 + 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (-0x1p-52 + 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1p-52 - 0.5 i) == -1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-52 - 0x1.0000000000001p0 i) == -1.570092458683774885078102529858632363236e-16 - 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (-0x1p-52 - 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0.5 i) == -9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i) == -7.666467083416870406778649849746878368519e-20 + 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0.5 i) == -9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i) == -7.666467083416870406778649849746878368519e-20 - 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1.fp-30 i) == -1.570753848123921942730162693731872690232 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1.fp-30 i) == -1.570753848123921942730162693731872690232 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + 0x1.fp-129 i) == -1.570796326794896619231321691639751442096 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + 0x1.fp-16385 i) == -1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0 i) == -pi/2 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0x1.fp-129 i) == -1.570796326794896619231321691639751442096 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0x1.fp-16385 i) == -1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffp0 i) == 0.0 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x1.000002p0 i) == 0.0 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x1p-23 i) == 0.0 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffp0 i) == 0.0 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x1.000002p0 i) == 0.0 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x1p-23 i) == 0.0 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.25 + 1.0 i) == 1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (0.25 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.25 - 1.0 i) == 1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (0.25 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-1025 i) == 5.235987755982988730771072305465838140329e-1 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-16385 i) == 5.235987755982988730771072305465838140329e-1 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-52 i) == 5.235987755982988730771072305465648369889e-1 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + 1.0 i) == 3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 1.0 i) == 3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-1025 i) == 5.235987755982988730771072305465838140329e-1 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-16385 i) == 5.235987755982988730771072305465838140329e-1 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-52 i) == 5.235987755982988730771072305465648369889e-1 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 1.0 i) == 3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 1.0 i) == 3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: casin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 1.570796326465624365239962068302568888898 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 1.570796326376055842114524927965556247908 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 1.570796326465624365239962068302568888898 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 1.570796326376055842114524927965556247908 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i) == 1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i) == 1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.0000000000000002p0 + 0x1p-63 i) == 1.570796326582978888921215348380499122131 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1.0000000000000002p0 - 0x1p-63 i) == 1.570796326582978888921215348380499122131 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1.0000000000001p0 + 0.0 i) == 1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1p-52 i) == 1.570796317204594913251280305810847349436 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 - 0.0 i) == 1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1p-52 i) == 1.570796317204594913251280305810847349436 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i) == 1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i) == 1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i) == 1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i) == 1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i) == 3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i) == 2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i) == 3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i) == 2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i) == 2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-129 + 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0x1p-23 i) == 2.846900380897707329917933005874691056564e-39 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i) == 2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i) == 1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i) == 2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-129 - 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0x1p-23 i) == 2.846900380897707329917933005874691056564e-39 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i) == 2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i) == 1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 5.757683115456107044287327268904964422212e-4933 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 5.757683115456107044287327268904964422212e-4933 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 + 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 + 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1p-105 + 0.5 i) == 2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-105 - 0.5 i) == 2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-112 + 0.5 i) == 1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-112 - 0.5 i) == 1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-52 + 0.5 i) == 1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-52 + 0x1.0000000000001p0 i) == 1.570092458683774885078102529858632363236e-16 + 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (0x1p-52 + 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1p-52 - 0.5 i) == 1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-52 - 0x1.0000000000001p0 i) == 1.570092458683774885078102529858632363236e-16 - 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (0x1p-52 - 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1p-63 + 0.5 i) == 9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 + 0x1.0000000000000002p0 i) == 7.666467083416870406778649849746878368519e-20 + 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 - 0.5 i) == 9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 - 0x1.0000000000000002p0 i) == 7.666467083416870406778649849746878368519e-20 - 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1.fp-30 i) == 1.570753848123921942730162693731872690232 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1.fp-30 i) == 1.570753848123921942730162693731872690232 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + 0x1.fp-129 i) == 1.570796326794896619231321691639751442096 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + 0x1.fp-16385 i) == 1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0 i) == pi/2 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0x1.fp-129 i) == 1.570796326794896619231321691639751442096 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0x1.fp-16385 i) == 1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # casinh -Test "Real part of: casinh (+0 + 1.5 i) == 0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (+0 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (+0 - 1.5 i) == 0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (+0 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.0 + 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.0 - 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 + 0x1p-52 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 + 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 - 0x1p-52 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 - 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0.0 i) == -8.813735870195430251942769895627079569917e-1 + 0.0 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == -8.813735870195430251942769895627079569917e-1 + 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0.0 i) == -8.813735870195430251942769895627079569917e-1 - 0.0 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == -8.813735870195430251942769895627079569917e-1 - 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i) == -8.813735870195430253092739958139610131001e-1 + 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i) == -8.813735870195430253092739958139610131001e-1 - 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000001p0 + 0x1p-52 i) == -8.813735870195431822418551933572982483664e-1 + 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (-0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000001p0 - 0x1p-52 i) == -8.813735870195431822418551933572982483664e-1 - 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (-0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1.000002p0 + 0.0 i) == -8.813736713132375348727889167749389235161e-1 + 0.0 i": +Test "Real part of: casinh (-0x1.000002p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000002p0 + 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (-0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.000002p0 - 0.0 i) == -8.813736713132375348727889167749389235161e-1 - 0.0 i": +Test "Real part of: casinh (-0x1.000002p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000002p0 - 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (-0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.fp-1025 + 0.5 i) == -6.222508863508420569166420770843207333493e-309 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 + 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 + 1.5 i) == -9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 - 0.5 i) == -6.222508863508420569166420770843207333493e-309 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 - 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 - 1.5 i) == -9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 + 0.5 i) == -3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 + 1.5 i) == -9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (-0x1.fp-129 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 - 0.5 i) == -3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 - 1.5 i) == -9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (-0x1.fp-129 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 + 0.5 i) == -9.402257155670418112159334875199821342890e-4933 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == -2.472906068161537187835415298076415423459e-4923 + 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 + 1.5 i) == -9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 - 0.5 i) == -9.402257155670418112159334875199821342890e-4933 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == -2.472906068161537187835415298076415423459e-4923 - 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 - 1.5 i) == -9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-30 + 1.0 i) == -4.247867098745151888768727039216644758847e-5 + 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (-0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-30 - 1.0 i) == -4.247867098745151888768727039216644758847e-5 - 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (-0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0.0 i) == -1.192092895507809676556842485683592032154e-7 + 0.0 i": +Test "Real part of: casinh (-0x1p-23 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0.5 i) == -1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0x1p-23 + 0.5 i) == -1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (-0x1p-23 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0x1.fp-129 i) == -1.192092895507809676556842485683592032154e-7 + 2.846900380897707329917933005874691056564e-39 i": +Test "Real part of: casinh (-0x1p-23 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0.0 i) == -1.192092895507809676556842485683592032154e-7 - 0.0 i": +Test "Real part of: casinh (-0x1p-23 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0.5 i) == -1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0x1p-23 - 0.5 i) == -1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (-0x1p-23 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0x1.fp-129 i) == -1.192092895507809676556842485683592032154e-7 - 2.846900380897707329917933005874691056564e-39 i": +Test "Real part of: casinh (-0x1p-23 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0.5 i) == -2.563950248511418570403591756798643804971e-16 + 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (-0x1p-52 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0x1.0000000000001p0 i) == -2.315303644582684770975188768022139415020e-8 + 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (-0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0.5 i) == -2.563950248511418570403591756798643804971e-16 - 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (-0x1p-52 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0x1.0000000000001p0 i) == -2.315303644582684770975188768022139415020e-8 - 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (-0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -2.588578361325995866221775673638805081337e-10 + 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 + 0x1.0000000000000002p0 i) == -5.116146586219826555037807251857670783420e-10 + 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -2.588578361325995866221775673638805081337e-10 - 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 - 0x1.0000000000000002p0 i) == -5.116146586219826555037807251857670783420e-10 - 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0.25 i) == -8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (-1.0 + 0.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0.5 i) == -9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0.5 i) == -9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (-1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0.25 i) == -8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (-1.0 - 0.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0.5 i) == -9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0.5 i) == -9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (-1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.0 + 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.0 - 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 + 0x1p-52 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 + 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 - 0x1p-52 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 - 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0.0 i) == 8.813735870195430251942769895627079569917e-1 + 0.0 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 8.813735870195430251942769895627079569917e-1 + 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0.0 i) == 8.813735870195430251942769895627079569917e-1 - 0.0 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 8.813735870195430251942769895627079569917e-1 - 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i) == 8.813735870195430253092739958139610131001e-1 + 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i) == 8.813735870195430253092739958139610131001e-1 - 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000001p0 + 0x1p-52 i) == 8.813735870195431822418551933572982483664e-1 + 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000001p0 - 0x1p-52 i) == 8.813735870195431822418551933572982483664e-1 - 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.000002p0 + 0.0 i) == 8.813736713132375348727889167749389235161e-1 + 0.0 i": +Test "Real part of: casinh (0x1.000002p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000002p0 + 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 + 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1.000002p0 - 0.0 i) == 8.813736713132375348727889167749389235161e-1 - 0.0 i": +Test "Real part of: casinh (0x1.000002p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000002p0 - 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 - 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1.fp-1025 + 0.5 i) == 6.222508863508420569166420770843207333493e-309 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 + 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 + 1.5 i) == 9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 - 0.5 i) == 6.222508863508420569166420770843207333493e-309 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 - 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 - 1.5 i) == 9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 + 0.5 i) == 3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 + 1.5 i) == 9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (0x1.fp-129 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 - 0.5 i) == 3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 - 1.5 i) == 9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (0x1.fp-129 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 + 0.5 i) == 9.402257155670418112159334875199821342890e-4933 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 2.472906068161537187835415298076415423459e-4923 + 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 + 1.5 i) == 9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 - 0.5 i) == 9.402257155670418112159334875199821342890e-4933 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 2.472906068161537187835415298076415423459e-4923 - 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 - 1.5 i) == 9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-30 + 1.0 i) == 4.247867098745151888768727039216644758847e-5 + 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-30 - 1.0 i) == 4.247867098745151888768727039216644758847e-5 - 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-23 + 0.0 i) == 1.192092895507809676556842485683592032154e-7 + 0.0 i": +Test "Real part of: casinh (0x1p-23 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 + 0.5 i) == 1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (0x1p-23 + 0.5 i) == 1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (0x1p-23 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-23 + 0x1.fp-129 i) == 1.192092895507809676556842485683592032154e-7 + 2.846900380897707329917933005874691056564e-39 i": +Test "Real part of: casinh (0x1p-23 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0.0 i) == 1.192092895507809676556842485683592032154e-7 - 0.0 i": +Test "Real part of: casinh (0x1p-23 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0.5 i) == 1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (0x1p-23 - 0.5 i) == 1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (0x1p-23 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-23 - 0x1.fp-129 i) == 1.192092895507809676556842485683592032154e-7 - 2.846900380897707329917933005874691056564e-39 i": +Test "Real part of: casinh (0x1p-23 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 + 0.5 i) == 2.563950248511418570403591756798643804971e-16 + 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (0x1p-52 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-52 + 0x1.0000000000001p0 i) == 2.315303644582684770975188768022139415020e-8 + 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 - 0.5 i) == 2.563950248511418570403591756798643804971e-16 - 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (0x1p-52 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-52 - 0x1.0000000000001p0 i) == 2.315303644582684770975188768022139415020e-8 - 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 2.588578361325995866221775673638805081337e-10 + 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 + 0x1.0000000000000002p0 i) == 5.116146586219826555037807251857670783420e-10 + 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 2.588578361325995866221775673638805081337e-10 - 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 - 0x1.0000000000000002p0 i) == 5.116146586219826555037807251857670783420e-10 - 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0.25 i) == 8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (1.0 + 0.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0.5 i) == 9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0.5 i) == 9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0.25 i) == 8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (1.0 - 0.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0.5 i) == 9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0.5 i) == 9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 # catan -Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i) == -7.853981633974482679822974223765039144191e-1 + 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x0.ffffffffffffffffp0 + 0x1p-33 i) == -7.853981633974483095919439232967553115548e-1 + 5.820766091346740722958646680334721192083e-11 i": +Test "Imaginary part of: catan (-0x0.ffffffffffffffffp0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i) == -7.853981373204155542484315721351697277336e-1 + 6.103515973639646453881721999956617260502e-5 i": +Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1.0000000000001p0 + 0x1p-27 i) == -7.853981633974484345157511161499711112683e-1 + 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (-0x1.0000000000001p0 + 0x1p-27 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.3p-73 + 1.0 i) == -7.853981633974483096156922786831527361009e-1 + 2.556052055225464683726753902092495938633e1 i": +Test "Imaginary part of: catan (-0x1.3p-73 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.3p-73 - 1.0 i) == -7.853981633974483096156922786831527361009e-1 - 2.556052055225464683726753902092495938633e1 i": +Test "Imaginary part of: catan (-0x1.3p-73 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i) == -1.570796326794896619231321691639751442099 + 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i) == -1.570796326794896619231321691639751442099 - 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i) == -1.570796326794896619231321691639751442097 + 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i) == -1.570796326794896619231321691639751442097 - 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i) == -7.853981633974483096156608458198757210493e-1 + 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i) == -7.853981633974483096156608458198757210493e-1 - 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-1022 + 0x0.ffffffffffffffffp0 i) == -2.052268400649188124723641491045245971623e-289 + 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (-0x1p-1022 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-1022 - 0x0.ffffffffffffffffp0 i) == -2.052268400649188124723641491045245971623e-289 - 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (-0x1p-1022 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-16382 + 0x0.ffffffffffffffffp0 i) == -3.100992811520163369065387859792822623745e-4913 + 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (-0x1p-16382 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-16382 - 0x0.ffffffffffffffffp0 i) == -3.100992811520163369065387859792822623745e-4913 - 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (-0x1p-16382 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-33 + 0x0.ffffffffffffffffp0 i) == -7.853981631937214964185249205444919953948e-1 + 1.178350206951907026002603046195591193050e1 i": +Test "Imaginary part of: catan (-0x1p-33 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-33 - 0x0.ffffffffffffffffp0 i) == -7.853981631937214964185249205444919953948e-1 - 1.178350206951907026002603046195591193050e1 i": +Test "Imaginary part of: catan (-0x1p-33 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-64 + 1.0 i) == -7.853981633974483096292133729759445264744e-1 + 2.252728336819822255606004394739073846245e1 i": +Test "Imaginary part of: catan (-0x1p-64 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-64 - 1.0 i) == -7.853981633974483096292133729759445264744e-1 - 2.252728336819822255606004394739073846245e1 i": +Test "Imaginary part of: catan (-0x1p-64 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-1.0 + 0x1p-64 i) == -7.853981633974483096156608458198757210500e-1 + 2.710505431213761085018632002174854278563e-20 i": +Test "Imaginary part of: catan (-1.0 + 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-1.0 - 0x1p-13 i) == -7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Imaginary part of: catan (-1.0 - 0x1p-13 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-1.0 - 0x1p-64 i) == -7.853981633974483096156608458198757210500e-1 - 2.710505431213761085018632002174854278563e-20 i": +Test "Imaginary part of: catan (-1.0 - 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i) == 7.853981633974482679822974223765039144191e-1 + 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x0.ffffffffffffffffp0 + 0x1p-33 i) == 7.853981633974483095919439232967553115548e-1 + 5.820766091346740722958646680334721192083e-11 i": +Test "Imaginary part of: catan (0x0.ffffffffffffffffp0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i) == 7.853981373204155542484315721351697277336e-1 + 6.103515973639646453881721999956617260502e-5 i": +Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1.0000000000001p0 + 0x1p-27 i) == 7.853981633974484345157511161499711112683e-1 + 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (0x1.0000000000001p0 + 0x1p-27 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.3p-73 + 1.0 i) == 7.853981633974483096156922786831527361009e-1 + 2.556052055225464683726753902092495938633e1 i": +Test "Imaginary part of: catan (0x1.3p-73 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.3p-73 - 1.0 i) == 7.853981633974483096156922786831527361009e-1 - 2.556052055225464683726753902092495938633e1 i": +Test "Imaginary part of: catan (0x1.3p-73 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i) == 1.570796326794896619231321691639751442099 + 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i) == 1.570796326794896619231321691639751442099 - 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i) == 1.570796326794896619231321691639751442097 + 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i) == 1.570796326794896619231321691639751442097 - 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-1020 + 1.0 i) == 7.853981633974483096156608458198757210493e-1 + 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (0x1p-1020 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-1020 - 1.0 i) == 7.853981633974483096156608458198757210493e-1 - 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (0x1p-1020 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-1022 + 0x0.ffffffffffffffffp0 i) == 2.052268400649188124723641491045245971623e-289 + 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (0x1p-1022 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-1022 - 0x0.ffffffffffffffffp0 i) == 2.052268400649188124723641491045245971623e-289 - 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (0x1p-1022 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-16382 + 0x0.ffffffffffffffffp0 i) == 3.100992811520163369065387859792822623745e-4913 + 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (0x1p-16382 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-16382 - 0x0.ffffffffffffffffp0 i) == 3.100992811520163369065387859792822623745e-4913 - 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (0x1p-16382 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-33 + 0x0.ffffffffffffffffp0 i) == 7.853981631937214964185249205444919953948e-1 + 1.178350206951907026002603046195591193050e1 i": +Test "Imaginary part of: catan (0x1p-33 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-33 - 0x0.ffffffffffffffffp0 i) == 7.853981631937214964185249205444919953948e-1 - 1.178350206951907026002603046195591193050e1 i": +Test "Imaginary part of: catan (0x1p-33 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-64 + 1.0 i) == 7.853981633974483096292133729759445264744e-1 + 2.252728336819822255606004394739073846245e1 i": +Test "Imaginary part of: catan (0x1p-64 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-64 - 1.0 i) == 7.853981633974483096292133729759445264744e-1 - 2.252728336819822255606004394739073846245e1 i": +Test "Imaginary part of: catan (0x1p-64 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (1.0 + 0x1p-64 i) == 7.853981633974483096156608458198757210500e-1 + 2.710505431213761085018632002174854278563e-20 i": +Test "Imaginary part of: catan (1.0 + 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (1.0 - 0x1p-13 i) == 7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Imaginary part of: catan (1.0 - 0x1p-13 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (1.0 - 0x1p-64 i) == 7.853981633974483096156608458198757210500e-1 - 2.710505431213761085018632002174854278563e-20 i": +Test "Imaginary part of: catan (1.0 - 0x1p-64 i)": ildouble: 1 ldouble: 1 # catanh -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-1022 i) == -2.252728336819822255604649142023466965703e1 + 2.052268400649188124723641491045245971623e-289 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-16382 i) == -2.252728336819822255604649142023466965703e1 + 3.100992811520163369065387859792822623745e-4913 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-33 i) == -1.178350206951907026002603046195591193050e1 + 7.853981631937214964185249205444919953948e-1 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-1022 i) == -2.252728336819822255604649142023466965703e1 - 2.052268400649188124723641491045245971623e-289 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-16382 i) == -2.252728336819822255604649142023466965703e1 - 3.100992811520163369065387859792822623745e-4913 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-33 i) == -1.178350206951907026002603046195591193050e1 - 7.853981631937214964185249205444919953948e-1 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i) == -2.871063043235098558826106732041811695767e-309 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i) == -2.871063043235098558826106732041811695767e-309 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i) == -1.516766904286822590927401983512575068153e-39 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i) == -1.516766904286822590927401983512575068153e-39 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1p-13 + 1.0 i) == -6.103515609841754902688560615027452023669e-5 + 7.853981671227386080775748393881580082970e-1 i": +Test "Real part of: catanh (-0x1p-13 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1p-13 - 1.0 i) == -6.103515609841754902688560615027452023669e-5 - 7.853981671227386080775748393881580082970e-1 i": +Test "Real part of: catanh (-0x1p-13 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-64 + 1.0 i) == -2.710505431213761085018632002174854278563e-20 + 7.853981633974483096156608458198757210500e-1 i": +Test "Real part of: catanh (-0x1p-64 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-64 - 1.0 i) == -2.710505431213761085018632002174854278563e-20 - 7.853981633974483096156608458198757210500e-1 i": +Test "Real part of: catanh (-0x1p-64 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 + 0x1.3p-73 i) == -2.556052055225464683726753902092495938633e1 + 7.853981633974483096156922786831527361009e-1 i": +Test "Real part of: catanh (-1.0 + 0x1.3p-73 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 + 0x1p-1020 i) == -3.538516356758520804574969980043991380025e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-1020 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 + 0x1p-64 i) == -2.252728336819822255606004394739073846245e1 + 7.853981633974483096292133729759445264744e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 - 0x1.3p-73 i) == -2.556052055225464683726753902092495938633e1 - 7.853981633974483096156922786831527361009e-1 i": +Test "Real part of: catanh (-1.0 - 0x1.3p-73 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 - 0x1p-1020 i) == -3.538516356758520804574969980043991380025e2 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-1020 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 - 0x1p-64 i) == -2.252728336819822255606004394739073846245e1 - 7.853981633974483096292133729759445264744e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-1022 i) == 2.252728336819822255604649142023466965703e1 + 2.052268400649188124723641491045245971623e-289 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-16382 i) == 2.252728336819822255604649142023466965703e1 + 3.100992811520163369065387859792822623745e-4913 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-33 i) == 1.178350206951907026002603046195591193050e1 + 7.853981631937214964185249205444919953948e-1 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-1022 i) == 2.252728336819822255604649142023466965703e1 - 2.052268400649188124723641491045245971623e-289 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-16382 i) == 2.252728336819822255604649142023466965703e1 - 3.100992811520163369065387859792822623745e-4913 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-33 i) == 1.178350206951907026002603046195591193050e1 - 7.853981631937214964185249205444919953948e-1 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i) == 2.871063043235098558826106732041811695767e-309 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i) == 2.871063043235098558826106732041811695767e-309 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i) == 1.516766904286822590927401983512575068153e-39 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i) == 1.516766904286822590927401983512575068153e-39 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i) == 6.103515973639646453881721999956617260502e-5 + 7.853981373204155542484315721351697277336e-1 i": +Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i) == 6.103515973639646453881721999956617260502e-5 - 7.853981373204155542484315721351697277336e-1 i": +Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i) == 3.725290298461914441624447420137706700965e-9 + 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1p-27 + 0x1.0000000000001p0 i) == 3.725290298461913200853528590596263270474e-9 + 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (0x1p-27 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i) == 3.725290298461914441624447420137706700965e-9 - 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1p-27 - 0x1.0000000000001p0 i) == 3.725290298461913200853528590596263270474e-9 - 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (0x1p-27 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-33 + 0x0.ffffffffffffffffp0 i) == 5.820766091346740722958646680334721192083e-11 + 7.853981633974483095919439232967553115548e-1 i": +Test "Real part of: catanh (0x1p-33 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-33 - 0x0.ffffffffffffffffp0 i) == 5.820766091346740722958646680334721192083e-11 - 7.853981633974483095919439232967553115548e-1 i": +Test "Real part of: catanh (0x1p-33 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-64 + 1.0 i) == 2.710505431213761085018632002174854278563e-20 + 7.853981633974483096156608458198757210500e-1 i": +Test "Real part of: catanh (0x1p-64 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-64 - 1.0 i) == 2.710505431213761085018632002174854278563e-20 - 7.853981633974483096156608458198757210500e-1 i": +Test "Real part of: catanh (0x1p-64 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 + 0x1.3p-73 i) == 2.556052055225464683726753902092495938633e1 + 7.853981633974483096156922786831527361009e-1 i": +Test "Real part of: catanh (1.0 + 0x1.3p-73 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 + 0x1p-1020 i) == 3.538516356758520804574969980043991380025e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-1020 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 + 0x1p-64 i) == 2.252728336819822255606004394739073846245e1 + 7.853981633974483096292133729759445264744e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 - 0x1.3p-73 i) == 2.556052055225464683726753902092495938633e1 - 7.853981633974483096156922786831527361009e-1 i": +Test "Real part of: catanh (1.0 - 0x1.3p-73 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 - 0x1p-1020 i) == 3.538516356758520804574969980043991380025e2 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-1020 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 - 0x1p-64 i) == 2.252728336819822255606004394739073846245e1 - 7.853981633974483096292133729759445264744e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-64 i)": ildouble: 1 ldouble: 1 # cbrt -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": ildouble: 1 ldouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": ildouble: 1 ldouble: 1 # ccos -Test "Real part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Real part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # ccosh -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Real part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Real part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 # cexp -Test "Real part of: cexp (-10000 + 0x1p16383 i) == 1.045876464564882298442774542991176546722e-4343 + 4.421154026488516836023811173959413420548e-4344 i": +Test "Real part of: cexp (-10000 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Real part of: cexp (-2.0 - 3.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Real part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (0 + 0x1p65 i) == 0.99888622066058013610642172179340364209972 - 0.047183876212354673805106149805700013943218 i": +Test "Imaginary part of: cexp (0 + 0x1p65 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (0 - 0x1p65 i) == 0.99888622066058013610642172179340364209972 + 0.047183876212354673805106149805700013943218 i": +Test "Imaginary part of: cexp (0 - 0x1p65 i)": float: 1 ifloat: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (11356.5625 + 0.75 i) == 9.052188470850960144814815984311663764287e4931 + 8.432986734191301036267148978260970230200e4931 i": +Test "Imaginary part of: cexp (11356.5625 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 idouble: 2 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Real part of: clog (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i) == -5.421010862427522170184200798202494495630e-20 + 3.548665303440282824232502561095699343814e-4516 i": +Test "Real part of: clog (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-100 i) == 8.237022655933121125560939513260027133767e-5 + 8.974094312218060110948251664314290484113e-31 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.234566p-30 + 1.0 i) == 5.614163921211322622623353961365728040115e-19 + 1.570796325735258575254858696548386439740 i": +Test "Real part of: clog (0x1.234566p-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fffffep+127 + 0x1.fffffep+127 i) == 89.06941264234832570836679262104313101776 + pi/4 i": +Test "Real part of: clog (0x1.fffffep+127 + 0x1.fffffep+127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i) == 11356.83823118610934184548269774874545400 + pi/4 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p+16383 i) == 11356.60974243783798653123798337822335902 + 0.4764674194737066993385333770295162295856 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 5.0844550531823026520677817684239496041087e-32 + 1.2627468605458094918919206628466016525397 i": +Test "Imaginary part of: clog (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-149 + 0x1p-149 i) == -102.9323563131518784484589700365392203592 + pi/4 i": +Test "Real part of: clog (0x1p-149 + 0x1p-149 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 4.4469229730850767799109418892826021157328e-20 + 1.2046235979300843056806465045930070146351 i": +Test "Real part of: clog (0x2dd46725bp-35 + 0x7783a1284p-35 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.234566p-40 - 1.0 i) == 2.325249110681915353442924915876654139373e-25 - 6.821881769213700828789403802671540158935e-1 i": +Test "Imaginary part of: clog10 (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.fp+16383 + 0x1p-16445 i) == 4932.061660674182269085496060792589701158 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (-0x1.fp+16383 - 0x1p-16445 i) == 4932.061660674182269085496060792589701158 - 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1p-16445 + 0x1.fp+16383 i) == 4932.061660674182269085496060792589701158 + 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (-0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (-0x1p-16445 - 0x1.fp+16383 i) == 4932.061660674182269085496060792589701158 - 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (-0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Real part of: clog10 (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i) == -2.354315103889861110220423157644627849164e-20 + 1.541165759405643564697852372112893034397e-4516 i": +Test "Real part of: clog10 (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Real part of: clog10 (0x1.234566p-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 308.4052305577487344482591243175787477115 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 308.3031705664207720674749211936626341569 + 0.2013595981366865903254995612594728746470 i": +Test "Real part of: clog10 (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i) == 4932.212175672014259683102930239951947672 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i) == 4932.112944269463028900262609694408579449 + 0.2069271710841128115912940666587802677383 i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1p-16445 i) == 4932.061660674182269085496060792589701158 + +0 i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 - 0x1p-16445 i) == 4932.061660674182269085496060792589701158 - 0 i": +Test "Real part of: clog10 (0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x11682p-23 + 0x7ffed1p-23 i) == 5.0916490233953865181284669870035717560498e-13 + 0.6784968969384861816694467029319146542069 i": +Test "Imaginary part of: clog10 (0x11682p-23 + 0x7ffed1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Real part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i) == -322.8546703496198318667349645920187712089 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (0x1p-149 + 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-149 + 0x1p-149 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (0x1p-149 - 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1p-16440 + 0x1p-16441 i) == -4948.884673709346821106688037612752099609 + 0.2013595981366865710389502301937289472543 i": +Test "Real part of: clog10 (0x1p-16440 + 0x1p-16441 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-16440 + 0x1p-16441 i) == -4948.884673709346821106688037612752099609 + 0.2013595981366865710389502301937289472543 i": +Test "Imaginary part of: clog10 (0x1p-16440 + 0x1p-16441 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1p-16445 + 0x1.fp+16383 i) == 4932.061660674182269085496060792589701158 + 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1p-16445 - 0x1.fp+16383 i) == 4932.061660674182269085496060792589701158 - 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1p-8190 + 1.0 i) == 2.920285685286322365786846845062520925172e-4932 + 6.821881769209206737428918127156778851051e-1 i": +Test "Real part of: clog10 (0x1p-8190 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Imaginary part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Imaginary part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x659b70ab7971bp-53 + 0x1f5d111e08abecp-53 i) == -1.0893543813872082317104059174982092534059e-30 + 0.5954257879188711495921161433751775633232 i": +Test "Imaginary part of: clog10 (0x659b70ab7971bp-53 + 0x1f5d111e08abecp-53 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 1.0529283395205396881397407610630442563938e-37 + 0.4947949395762683446121140513971996916447 i": +Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x81b7efa81fc35ad1p-65 + 0x1ef4b835f1c79d812p-65 i) == -4.3074341162203896332989394770760901408798e-39 + 0.5709443672155660428417571212549720987784 i": +Test "Imaginary part of: clog10 (0x81b7efa81fc35ad1p-65 + 0x1ef4b835f1c79d812p-65 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i) == -4.2289432987513243393180377141513840878196e-30 + 0.4252020027092323591068799049905597805296 i": +Test "Real part of: clog10 (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos -Test "cos (0x1p+50) == 8.68095904660550604334592502063501320395739e-01": +Test "cos (0x1p+50)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 @@ -4529,49 +4529,49 @@ ildouble: 1 ldouble: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "cos_downward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_downward (10)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_downward (9)": double: 1 float: 1 idouble: 1 @@ -4580,49 +4580,49 @@ ildouble: 1 ldouble: 1 # cos_tonearest -Test "cos_tonearest (2) == -0.4161468365471423869975682295007621897660": +Test "cos_tonearest (2)": float: 1 ifloat: 1 -Test "cos_tonearest (8) == -0.1455000338086135258688413818311946826093": +Test "cos_tonearest (8)": ildouble: 1 ldouble: 1 -Test "cos_tonearest (9) == -0.9111302618846769883682947111811653112463": +Test "cos_tonearest (9)": ildouble: 1 ldouble: 1 # cos_towardzero -Test "cos_towardzero (1) == 0.5403023058681397174009366074429766037323": +Test "cos_towardzero (1)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (10) == -0.8390715290764524522588639478240648345199": +Test "cos_towardzero (10)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (4) == -0.6536436208636119146391681830977503814241": +Test "cos_towardzero (4)": double: 1 idouble: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": double: 1 float: 1 idouble: 1 @@ -4631,171 +4631,171 @@ ildouble: 1 ldouble: 1 # cos_upward -Test "cos_upward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_upward (1)": float: 1 ifloat: 1 -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": ildouble: 1 ldouble: 1 -Test "cos_upward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_upward (2)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_upward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_upward (4)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_upward (5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": double: 1 idouble: 1 -Test "cos_upward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_upward (8)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": ildouble: 1 ldouble: 1 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 2 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_tonearest -Test "cosh_tonearest (22) == 1792456423.065795780980053377632656584997": +Test "cosh_tonearest (22)": ldouble: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 2 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_upward -Test "cosh_upward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_upward (22)": ildouble: 2 -Test "cosh_upward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_upward (23)": ildouble: 2 ldouble: 1 -Test "cosh_upward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_upward (24)": double: 1 idouble: 1 ildouble: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 6 ldouble: 6 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 4 idouble: 2 ifloat: 4 ildouble: 3 ldouble: 3 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 5 idouble: 1 ifloat: 5 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 ildouble: 4 ldouble: 4 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 3 idouble: 2 @@ -4804,314 +4804,314 @@ ildouble: 1 ldouble: 1 # csin -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Imaginary part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Imaginary part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csin (-2 - 3 i) == -9.15449914691142957346729954460983256 + 4.16890695996656435075481305885375484 i": +Test "Imaginary part of: csin (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Real part of: csin (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Imaginary part of: csin (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Imaginary part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Imaginary part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # csinh -Test "Real part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Real part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Real part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Real part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Real part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i) == 6.788430486774966350907249113759995429568e-155 - 1.638872094839911521020410942677082920935e-154 i": +Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i) == 1.638872094839911521020410942677082920935e-154 + 6.788430486774966350907249113759995429568e-155 i": +Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-1073 + 0x1p-1073 i) == 3.453664695497464982856905711457966660085e-162 + 1.430554756764195530630723976279903095110e-162 i": +Test "Imaginary part of: csqrt (0x1p-1073 + 0x1p-1073 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-1074 + 0x1p-1074 i) == 2.442109726130830256743814843868934877597e-162 + 1.011554969366634726113090867589031782487e-162 i": +Test "Imaginary part of: csqrt (0x1p-1074 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-147 + 0x1p-147 i) == 8.225610928685557596194006925540350401606e-23 + 3.407159605465907500737319471202779419102e-23 i": +Test "Imaginary part of: csqrt (0x1p-147 + 0x1p-147 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-149 + 0x1p-149 i) == 4.112805464342778798097003462770175200803e-23 + 1.703579802732953750368659735601389709551e-23 i": +Test "Imaginary part of: csqrt (0x1p-149 + 0x1p-149 i)": ildouble: 1 ldouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Real part of: ctan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Imaginary part of: ctan (0x1p1023 + 1 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Real part of: ctan (0x1p127 + 1 i)": float: 1 ifloat: 1 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 -Test "Real part of: ctan (1 + 45 i) == 1.490158918874345552942703234806348520895e-39 + 1.000000000000000000000000000000000000001 i": +Test "Real part of: ctan (1 + 45 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 47 i) == 2.729321264492904590777293425576722354636e-41 + 1.0 i": +Test "Real part of: ctan (1 + 47 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 3 ifloat: 3 ildouble: 4 ldouble: 4 # ctan_tonearest -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 3 ifloat: 3 ildouble: 4 ldouble: 4 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 @@ -5120,204 +5120,204 @@ ildouble: 1 ldouble: 1 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Real part of: ctanh (1 + 0x1p1023 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Imaginary part of: ctanh (1 + 0x1p127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (45 + 1 i) == 1.000000000000000000000000000000000000001 + 1.490158918874345552942703234806348520895e-39 i": +Test "Imaginary part of: ctanh (45 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (47 + 1 i) == 1.0 + 2.729321264492904590777293425576722354636e-41 i": +Test "Imaginary part of: ctanh (47 + 1 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 3 ifloat: 3 ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 3 ifloat: 3 ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # ctanh_upward -Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 2 ldouble: 2 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0.75) == 0.288844366346484868401062165408589223": +Test "erfc (0.75)": float: 1 ifloat: 1 -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": ildouble: 1 ldouble: 1 -Test "erfc (0x1.ffffc8p+2) == 1.122671365033056305522366683719541099329e-29": +Test "erfc (0x1.ffffc8p+2)": double: 1 idouble: 1 -Test "erfc (1.25) == 0.0770998717435417698634765188027188596": +Test "erfc (1.25)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # exp -Test "exp (0.75) == 2.11700001661267466854536981983709561": +Test "exp (0.75)": ildouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": ildouble: 1 ldouble: 1 -Test "exp10 (0.75) == 5.62341325190349080394951039776481231": +Test "exp10 (0.75)": ildouble: 2 ldouble: 2 -Test "exp10 (3) == 1000": +Test "exp10 (3)": ildouble: 8 ldouble: 8 # exp_downward -Test "exp_downward (1) == e": +Test "exp_downward (1)": ildouble: 1 ldouble: 1 -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": double: 1 float: 1 idouble: 1 @@ -5326,17 +5326,17 @@ ildouble: 1 ldouble: 1 # exp_towardzero -Test "exp_towardzero (1) == e": +Test "exp_towardzero (1)": ildouble: 1 ldouble: 1 -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": double: 1 float: 1 idouble: 1 @@ -5345,122 +5345,132 @@ ildouble: 1 ldouble: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": double: 1 float: 1 idouble: 1 ifloat: 1 # expm1 -Test "expm1 (-45.0) == -0.9999999999999999999713748141945060635553": +Test "expm1 (-45.0)": ildouble: 1 ldouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": ildouble: 1 -Test "expm1 (11356.25) == 9.05128237311923300051376115753226014206e+4931": +Test "expm1 (11356.25)": ildouble: 1 ldouble: 1 # gamma -Test "gamma (-0.5) == log(2*sqrt(pi))": +Test "gamma (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 +Test "gamma (0.7)": +float: 1 +ifloat: 1 +Test "gamma (1.2)": +double: 1 +float: 2 +idouble: 1 +ifloat: 2 +ildouble: 1 +ldouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-0x1.001000001p+593) == -3.927269966354206207832593635798954916263e-90": +Test "j0 (-0x1.001000001p+593)": ildouble: 2 ldouble: 2 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 1 ifloat: 1 -Test "j0 (0x1p1023) == -1.5665258060609012834424478437196679802783e-155": +Test "j0 (0x1p1023)": double: 1 idouble: 1 -Test "j0 (0x1p16382) == -1.2193782500509000574176799046642541129387e-2466": +Test "j0 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (0.75) == 0.349243602174862192523281016426251335": +Test "j1 (0.75)": double: 1 idouble: 1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "j1 (0x1p16382) == 8.0839224448726336195866026476176740513439e-2467": +Test "j1 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 float: 1 idouble: 1 @@ -5469,174 +5479,174 @@ ildouble: 1 ldouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, 0.75) == 0.349243602174862192523281016426251335": +Test "jn (1, 0.75)": double: 1 idouble: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 5 float: 2 idouble: 5 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, -1.0) == -0.0195633539826684059189053216217515083": +Test "jn (3, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 1.0) == 0.0195633539826684059189053216217515083": +Test "jn (3, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 5 float: 2 idouble: 5 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": ildouble: 1 ldouble: 1 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": ildouble: 2 ldouble: 2 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 1 float: 3 idouble: 1 ifloat: 3 ildouble: 2 ldouble: 2 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": float: 4 ifloat: 4 ildouble: 2 ldouble: 2 # lgamma -Test "lgamma (-0.5) == log(2*sqrt(pi))": +Test "lgamma (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -5645,116 +5655,121 @@ ildouble: 1 ldouble: 1 # log -Test "log (e) == 1": +Test "log (e)": float: 1 ifloat: 1 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": ildouble: 1 ldouble: 1 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # pow -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": +ildouble: 1 +ldouble: 1 + +# pow10 +Test "pow10 (0.75)": ildouble: 1 ldouble: 1 # pow_downward -Test "pow_downward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_downward (1.0625, 1.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # pow_towardzero -Test "pow_towardzero (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_towardzero (1.0625, 1.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "pow_upward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_upward (1.5, 1.03125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # sin -Test "sin (-0x1p65) == 0.047183876212354673805106149805700013943218": +Test "sin (-0x1p65)": float: 1 ifloat: 1 -Test "sin (0x1.fffff8p+127) == 4.85786063130487339701113680434728152037092e-02": +Test "sin (0x1.fffff8p+127)": float: 1 -Test "sin (0x1p+127) == 6.23385512955870240370428801097126489001833e-01": +Test "sin (0x1p+127)": float: 1 -Test "sin (0x1p65) == -0.047183876212354673805106149805700013943218": +Test "sin (0x1p65)": float: 1 ifloat: 1 # sin_downward -Test "sin_downward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_downward (1)": ildouble: 1 ldouble: 1 -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_downward (2)": double: 1 idouble: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_downward (4)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sin_downward (7) == 0.6569865987187890903969990915936351779369": +Test "sin_downward (7)": ildouble: 1 ldouble: 1 -Test "sin_downward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_downward (8)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_downward (9)": double: 1 float: 1 idouble: 1 @@ -5763,50 +5778,50 @@ ildouble: 1 ldouble: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 -Test "sin_tonearest (10) == -0.5440211108893698134047476618513772816836": +Test "sin_tonearest (10)": ildouble: 1 ldouble: 1 -Test "sin_tonearest (4) == -0.7568024953079282513726390945118290941359": +Test "sin_tonearest (4)": ildouble: 1 ldouble: 1 -Test "sin_tonearest (9) == 0.4121184852417565697562725663524351793439": +Test "sin_tonearest (9)": ildouble: 1 ldouble: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (2) == 0.9092974268256816953960198659117448427023": +Test "sin_towardzero (2)": double: 1 idouble: 1 -Test "sin_towardzero (3) == 0.1411200080598672221007448028081102798469": +Test "sin_towardzero (3)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 -Test "sin_towardzero (6) == -0.2794154981989258728115554466118947596280": +Test "sin_towardzero (6)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (7) == 0.6569865987187890903969990915936351779369": +Test "sin_towardzero (7)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (8) == 0.9893582466233817778081235982452886721164": +Test "sin_towardzero (8)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": double: 1 float: 1 idouble: 1 @@ -5815,949 +5830,949 @@ ildouble: 1 ldouble: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sin_upward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_upward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_upward (3)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_upward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_upward (6)": ildouble: 1 ldouble: 1 -Test "sin_upward (7) == 0.6569865987187890903969990915936351779369": +Test "sin_upward (7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sin_upward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_upward (8)": float: 1 ifloat: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (-0x1p65, &sin_res, &cos_res) puts 0.047183876212354673805106149805700013943218 in sin_res": +Test "sincos (-0x1p65) extra output 1": float: 1 ifloat: 1 -Test "sincos (0x1.fffff8p+127, &sin_res, &cos_res) puts 4.85786063130487339701113680434728152037092e-02 in sin_res": +Test "sincos (0x1.fffff8p+127) extra output 1": float: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 6.23385512955870240370428801097126489001833e-01 in sin_res": +Test "sincos (0x1p+127) extra output 1": float: 1 -Test "sincos (0x1p+50, &sin_res, &cos_res) puts 8.68095904660550604334592502063501320395739e-01 in cos_res": +Test "sincos (0x1p+50) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p65, &sin_res, &cos_res) puts -0.047183876212354673805106149805700013943218 in sin_res": +Test "sincos (0x1p65) extra output 1": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +ildouble: 1 +ldouble: 1 +Test "sincos (M_PI_6l*2.0) extra output 2": double: 1 float: 1 idouble: 1 ifloat: 1 -ildouble: 1 -ldouble: 1 # sinh -Test "sinh (0.75) == 0.822316731935829980703661634446913849": +Test "sinh (0.75)": double: 1 ildouble: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # sinh_upward -Test "sinh_upward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_upward (22)": ildouble: 1 ldouble: 1 -Test "sinh_upward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_upward (23)": ildouble: 1 ldouble: 1 -Test "sinh_upward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_upward (24)": double: 1 idouble: 1 # tan -Test "tan (-0xc.90fdbp-4) == -1.0000000437113909572052640953950483705005": +Test "tan (-0xc.90fdbp-4)": float: 1 ifloat: 1 -Test "tan (-0xc.90fdcp-4) == -1.0000001629206928242190327320047489394217": +Test "tan (-0xc.90fdcp-4)": float: 1 ifloat: 1 -Test "tan (-0xc.90fep-4) == -1.0000006397580424009014454926842136804016": +Test "tan (-0xc.90fep-4)": float: 1 ifloat: 1 -Test "tan (-0xc.91p-4) == -1.0000044544650244953647966900221905361131": +Test "tan (-0xc.91p-4)": float: 1 ifloat: 1 -Test "tan (-0xc.92p-4) == -1.0004928571392300571266638743539017593717": +Test "tan (-0xc.92p-4)": float: 1 ifloat: 1 -Test "tan (-0xc.94p-4) == -1.0014703786820082237342656561856877993328": +Test "tan (-0xc.94p-4)": float: 1 ifloat: 1 -Test "tan (0x1p16383) == 0.422722393732022337800504160054440141575": +Test "tan (0x1p16383)": ildouble: 1 ldouble: 1 -Test "tan (0xc.90fdbp-4) == 1.0000000437113909572052640953950483705005": +Test "tan (0xc.90fdbp-4)": float: 1 ifloat: 1 -Test "tan (0xc.90fdcp-4) == 1.0000001629206928242190327320047489394217": +Test "tan (0xc.90fdcp-4)": float: 1 ifloat: 1 -Test "tan (0xc.90fep-4) == 1.0000006397580424009014454926842136804016": +Test "tan (0xc.90fep-4)": float: 1 ifloat: 1 -Test "tan (0xc.91p-4) == 1.0000044544650244953647966900221905361131": +Test "tan (0xc.91p-4)": float: 1 ifloat: 1 -Test "tan (0xc.92p-4) == 1.0004928571392300571266638743539017593717": +Test "tan (0xc.92p-4)": float: 1 ifloat: 1 -Test "tan (0xc.94p-4) == 1.0014703786820082237342656561856877993328": +Test "tan (0xc.94p-4)": float: 1 ifloat: 1 -Test "tan (1e22) == -1.628778225606898878549375936939548513545": +Test "tan (1e22)": ildouble: 1 ldouble: 1 -Test "tan (pi/4) == 1": +Test "tan (pi/4)": double: 1 float: 1 idouble: 1 ifloat: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tan_downward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_downward (3)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (4) == 1.1578212823495775831373424182673239231198": +Test "tan_downward (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_downward (5)": ildouble: 1 ldouble: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tan_downward (7) == 0.8714479827243187364564508896003135663222": +Test "tan_downward (7)": double: 1 idouble: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_tonearest -Test "tan_tonearest (1) == 1.5574077246549022305069748074583601730873": +Test "tan_tonearest (1)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (2) == -2.1850398632615189916433061023136825434320": +Test "tan_tonearest (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_tonearest (6) == -0.2910061913847491570536995888681755428312": +Test "tan_tonearest (6)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (8) == -6.7997114552203786999252627596086333648814": +Test "tan_tonearest (8)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (9) == -0.4523156594418098405903708757987855343087": +Test "tan_tonearest (9)": ildouble: 1 ldouble: 1 # tan_towardzero -Test "tan_towardzero (1) == 1.5574077246549022305069748074583601730873": +Test "tan_towardzero (1)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (2) == -2.1850398632615189916433061023136825434320": +Test "tan_towardzero (2)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (6) == -0.2910061913847491570536995888681755428312": +Test "tan_towardzero (6)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (7) == 0.8714479827243187364564508896003135663222": +Test "tan_towardzero (7)": double: 1 idouble: 1 -Test "tan_towardzero (8) == -6.7997114552203786999252627596086333648814": +Test "tan_towardzero (8)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_upward (2)": ildouble: 1 ldouble: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (4) == 1.1578212823495775831373424182673239231198": +Test "tan_upward (4)": double: 1 idouble: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tan_upward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_upward (6)": ildouble: 1 ldouble: 1 -Test "tan_upward (7) == 0.8714479827243187364564508896003135663222": +Test "tan_upward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_upward (8)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tan_upward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_upward (9)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x0.ffffffffffffffffp0) == -1.8446744073709551616422784335098467139470e+19": +Test "tgamma (-0x0.ffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.000002p0) == 8.3886075772158332060084424806449513922858e+06": +Test "tgamma (-0x1.000002p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.0a32a2p+5) == 1.8125267978155035272941154746083439329912e-37": +Test "tgamma (-0x1.0a32a2p+5)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.5800000080001p+7) == -3.1439271448823567326093363350637118195240e-304": +Test "tgamma (-0x1.5800000080001p+7)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tgamma (-0x1.fffffffffffffp0) == 2.2517998136852484613921675492337776673289e+15": +Test "tgamma (-0x1.fffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x13.ffffep0) == 2.1550026214525536756224040483579183652119e-13": +Test "tgamma (-0x13.ffffep0)": float: 1 ifloat: 1 -Test "tgamma (-0x13.ffffffffffffffep0) == 2.3694367893405502075347562184931828448654e-01": +Test "tgamma (-0x13.ffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x13.ffffffffffffp0) == 1.1569515572952029402736625857313236848570e-04": +Test "tgamma (-0x13.ffffffffffffp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x14.000000000001p0) == -1.1569515572951781096476686854873801225397e-04": +Test "tgamma (-0x14.000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x1d.ffffep0) == 1.9765721589464867957912772592816027583176e-27": +Test "tgamma (-0x1d.ffffep0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1d.ffffffffffffffep0) == 2.1732499046818166459536268654187775086902e-15": +Test "tgamma (-0x1d.ffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1e.000000000000002p0) == -2.1732499046818166201837145753965837196590e-15": +Test "tgamma (-0x1e.000000000000002p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x1e.00002p0) == -1.9765463890341964384070157599286498212650e-27": +Test "tgamma (-0x1e.00002p0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1f4.00000000000002p0) == -2.9528489142763131406565394149878256133744e-1118": +Test "tgamma (-0x1f4.00000000000002p0)": ildouble: 3 ldouble: 3 -Test "tgamma (-0x1p-24) == -1.6777216577215723853867349114260580375249e+07": +Test "tgamma (-0x1p-24)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.0000000000000004p0) == -2.3058430092136939515386078324507664305064e+18": +Test "tgamma (-0x2.0000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.0000000000002p0) == -1.1258999068426235386078324507668462444260e+15": +Test "tgamma (-0x2.0000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.000004p0) == -2.0971515386080557574407223895988378776747e+06": +Test "tgamma (-0x2.000004p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.fffffcp0) == -6.9905087601970247876992248591045142913324e+05": +Test "tgamma (-0x2.fffffcp0)": double: 1 idouble: 1 -Test "tgamma (-0x27.ffffcp0) == 3.2129279441390812141195076945616975790225e-43": +Test "tgamma (-0x27.ffffcp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x27.fffffffffffep0) == 1.7249032006742266376460389310340465554361e-34": +Test "tgamma (-0x27.fffffffffffep0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.000000000002p0) == -1.7249032006741359094184881234822934593822e-34": +Test "tgamma (-0x28.000000000002p0)": double: 1 idouble: 1 -Test "tgamma (-0x28.00004p0) == -3.2128372159115252365699015758097981155793e-43": +Test "tgamma (-0x28.00004p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.ffffcp0) == -7.8364103489619817539676737414096652170685e-45": +Test "tgamma (-0x28.ffffcp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.fffffffffffep0) == -4.2070809772542120404320040128839297118648e-36": +Test "tgamma (-0x28.fffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.ffffffffffffffcp0) == -8.6161018414163982777002940498289948893044e-33": +Test "tgamma (-0x28.ffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.000000000000004p0) == 8.6161018414163980549537337663264762179535e-33": +Test "tgamma (-0x29.000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.000000000002p0) == 4.2070809772539892938717205103652583609422e-36": +Test "tgamma (-0x29.000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.00004p0) == 7.8361876024016854597745353972619195760515e-45": +Test "tgamma (-0x29.00004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.ffffcp0) == 1.8658121573125798145204120066590953505132e-46": +Test "tgamma (-0x29.ffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2a.00004p0) == -1.8657587834931410688246126853566488626385e-46": +Test "tgamma (-0x2a.00004p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x2ed.fffffffffffffcp0) == 6.9801511765871818502006905472380418430269e-1817": +Test "tgamma (-0x2ed.fffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3.0000000000002p0) == 3.7529996894754112398038859470009084971438e+14": +Test "tgamma (-0x3.0000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3.000004p0) == 6.9905045731381300146131914617735687322025e+05": +Test "tgamma (-0x3.000004p0)": double: 1 idouble: 1 -Test "tgamma (-0x3.fffffcp0) == 1.7476272942159602684441970627092458855771e+05": +Test "tgamma (-0x3.fffffcp0)": float: 1 ifloat: 1 -Test "tgamma (-0x3.ffffffffffffep0) == 9.3824992236885396088236184658402406857503e+13": +Test "tgamma (-0x3.ffffffffffffep0)": double: 1 idouble: 1 -Test "tgamma (-0x3.fffffffffffffffcp0) == 1.9215358410114116272942156951799168638773e+17": +Test "tgamma (-0x3.fffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x31.fffffffffffep0) == 4.6273774273632946947805289899230181990085e-51": +Test "tgamma (-0x31.fffffffffffep0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x32.000000000000004p0) == -9.4768689712397633101385547903658075308777e-48": +Test "tgamma (-0x32.000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x32.000000000002p0) == -4.6273774273630367887073532197576655720178e-51": +Test "tgamma (-0x32.000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3e7.fffffffffffffcp0) == 4.4768809295877296071892611539415773519036e-2552": +Test "tgamma (-0x3e7.fffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3e8.00000000000004p0) == -4.4768809295877261735541135972060089530309e-2552": +Test "tgamma (-0x3e8.00000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.0000000000000008p0) == -9.6076792050570581270578430482008313684602e+16": +Test "tgamma (-0x4.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.000008p0) == -8.7381270578483499672965708923121931082305e+04": +Test "tgamma (-0x4.000008p0)": float: 2 ifloat: 2 -Test "tgamma (-0x4.fffff8p0) == -1.7476280884325863043793087474680780379554e+04": +Test "tgamma (-0x4.fffff8p0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.ffffffffffffcp0) == -9.3824992236885475509805702650262155809819e+12": +Test "tgamma (-0x4.ffffffffffffcp0)": double: 1 idouble: 1 -Test "tgamma (-0x4e2.00000000000008p0) == -5.4651488569236421026544487194247355967789e-3315": +Test "tgamma (-0x4e2.00000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.0000000000000008p0) == 1.9215358410114116252449019429734996071487e+16": +Test "tgamma (-0x5.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.0000000000004p0) == 9.3824992236885191156860964016850034672946e+12": +Test "tgamma (-0x5.0000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.000008p0) == 1.7476252449031389167286893378510439443844e+04": +Test "tgamma (-0x5.000008p0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.fffff8p0) == 2.9127137122026653716311560165769071985443e+03": +Test "tgamma (-0x5.fffff8p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x5.ffffffffffffcp0) == 1.5637498706147581566449098589862357835505e+12": +Test "tgamma (-0x5.ffffffffffffcp0)": double: 1 idouble: 1 -Test "tgamma (-0x5db.fffffffffffff8p0) == 1.8718211510339187689122114747834510481993e-4099": +Test "tgamma (-0x5db.fffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.0000000000000008p0) == -3.2025597350190193751766884234743511972877e+15": +Test "tgamma (-0x6.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.000008p0) == -2.9127085100239567622341538102130981196910e+03": +Test "tgamma (-0x6.000008p0)": double: 1 idouble: 1 -Test "tgamma (-0x6.fffff8p0) == -4.1610198723079349791939054365613377035519e+02": +Test "tgamma (-0x6.fffff8p0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tgamma (-0x6.ffffffffffffcp0) == -2.2339283865925119357965832452642909859289e+11": +Test "tgamma (-0x6.ffffffffffffcp0)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "tgamma (-0x63.fffffffffffcp0) == 7.5400833348840965463348754984345825364294e-145": +Test "tgamma (-0x63.fffffffffffcp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x63.ffffffffffffff8p0) == 1.5442090669841618542494279375256856430049e-141": +Test "tgamma (-0x63.ffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x64.000000000000008p0) == -1.5442090669841617554527108348771968070612e-141": +Test "tgamma (-0x64.000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x64.000000000004p0) == -7.5400833348831085791638490135462230991587e-145": +Test "tgamma (-0x64.000000000004p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x6d6.00000000000008p0) == -4.2925786447266421378134368786479937285900e-4902": +Test "tgamma (-0x6d6.00000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.0000000000000008p0) == 4.5750853357414562499689653215166468353753e+14": +Test "tgamma (-0x7.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.0000000000004p0) == 2.2339283865925039372192897706214475877342e+11": +Test "tgamma (-0x7.0000000000004p0)": double: 4 idouble: 4 ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.000008p0) == 4.1610118737306415004517215226199741948733e+02": +Test "tgamma (-0x7.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.fffff8p0) == 5.2012751504050764429534086402871289946986e+01": +Test "tgamma (-0x7.fffff8p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.ffffffffffffcp0) == 2.7924104832406402297655703264222230055898e+10": +Test "tgamma (-0x7.ffffffffffffcp0)": double: 2 idouble: 2 -Test "tgamma (-0x7.fffffffffffffff8p0) == 5.7188566696768203227694481100089533685959e+13": +Test "tgamma (-0x7.fffffffffffffff8p0)": ildouble: 4 ldouble: 4 -Test "tgamma (-0x8.000000000000001p0) == -2.8594283348384101534210280804672371201060e+13": +Test "tgamma (-0x8.000000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x8.00001p0) == -2.6006296115134418896533598545925084576702e+01": +Test "tgamma (-0x8.00001p0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x9.ffffffffffff8p0) == 1.5513391573559147700413058496716749249803e+08": +Test "tgamma (-0x9.ffffffffffff8p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x95.fffffffffff8p0) == 6.1582369322723207086020016423767264008839e-250": +Test "tgamma (-0x95.fffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x95.ffffffffffffffp0) == 1.2612069237291916400144732227892704713839e-246": +Test "tgamma (-0x95.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x96.000000000008p0) == -6.1582369322705655439003240743176243138734e-250": +Test "tgamma (-0x96.000000000008p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0xa.000000000000001p0) == -3.1771425942649001698860433502350057763905e+11": +Test "tgamma (-0xa.000000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xa.0000000000008p0) == -1.5513391573559018084419393002828541166901e+08": +Test "tgamma (-0xa.0000000000008p0)": double: 1 idouble: 1 -Test "tgamma (-0xa.00001p0) == -2.8895878754728051776830454190076999107021e-01": +Test "tgamma (-0xa.00001p0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0xb4.ffffffffffffffp0) == -1.9816628031468191243385005680879281767694e-315": +Test "tgamma (-0xb4.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb5.00000000000001p0) == 1.9816628031468188382579700510291588022368e-315": +Test "tgamma (-0xb5.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb5.000000000008p0) == 9.6760879059888966544677044221698800670218e-319": +Test "tgamma (-0xb5.000000000008p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xb5.ffffffffffffffp0) == 1.0888257160147357826865964233809723297472e-317": +Test "tgamma (-0xb5.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb6.00000000000001p0) == -1.0888257160147356253334423783317128355514e-317": +Test "tgamma (-0xb6.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb6.fffffffffff8p0) == -2.9052086428846935908287469917922960610289e-323": +Test "tgamma (-0xb6.fffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb6.ffffffffffffffp0) == -5.9498673006269714905418984659220067091260e-320": +Test "tgamma (-0xb6.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb7.fffffffffff8p0) == 1.5789177406982032823826953250736039527543e-325": +Test "tgamma (-0xb7.fffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb7.ffffffffffffffp0) == 3.2336235329494410277123118903958061569834e-322": +Test "tgamma (-0xb7.ffffffffffffffp0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xb8.000000000008p0) == -1.5789177406977349925854817486109369828857e-325": +Test "tgamma (-0xb8.000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbb.ffffffffffffffp0) == 2.6730392040715350119087465463119939092815e-331": +Test "tgamma (-0xbb.ffffffffffffffp0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xbc.00000000000001p0) == -2.6730392040715346232108532050343031951651e-331": +Test "tgamma (-0xbc.00000000000001p0)": ildouble: 3 ldouble: 3 -Test "tgamma (-0xbd.00000000000001p0) == 1.4143064571807061497431633629389135273431e-333": +Test "tgamma (-0xbd.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbe.00000000000001p0) == -7.4437181956879271033676895858841525581153e-336": +Test "tgamma (-0xbe.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbe.ffffffffffffffp0) == -3.8972346574282346536709453101948570578636e-338": +Test "tgamma (-0xbe.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbf.00000000000001p0) == 3.8972346574282340852496542564155275274974e-338": +Test "tgamma (-0xbf.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xf9.ffffffffffffffp0) == 2.2289142548411573883553287678043297937797e-476": +Test "tgamma (-0xf9.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xfa.00000000000001p0) == -2.2289142548411570466476165308364665814265e-476": +Test "tgamma (-0xfa.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-1.5) == 2.3632718012073547030642233111215269103967e+00": +Test "tgamma (-1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-2.5) == -9.4530872048294188122568932444861076415869e-01": +Test "tgamma (-2.5)": double: 1 idouble: 1 -Test "tgamma (-4.5) == -6.0019601300504246427027893615784810422774e-02": +Test "tgamma (-4.5)": ildouble: 1 ldouble: 1 -Test "tgamma (-5.5) == 1.0912654781909862986732344293779056440504e-02": +Test "tgamma (-5.5)": float: 1 ifloat: 1 -Test "tgamma (-6.5) == -1.6788699664476712287280529682737009908468e-03": +Test "tgamma (-6.5)": float: 1 ifloat: 1 -Test "tgamma (-7.5) == 2.2384932885968949716374039576982679877958e-04": +Test "tgamma (-7.5)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-8.5) == -2.6335215159963470254557693619979623385833e-05": +Test "tgamma (-8.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-9.5) == 2.7721279115751021320587045915768024616666e-06": +Test "tgamma (-9.5)": ildouble: 2 ldouble: 2 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0x1.fffffep0) == 9.9999994960018563231526611134590489120697e-01": +Test "tgamma (0x1.fffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x1.fffffffffffffffep0) == 9.9999999999999999995416163053934024243282e-01": +Test "tgamma (0x1.fffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x1p-24) == 1.6777215422784394050795179874582764575261e+07": +Test "tgamma (0x1p-24)": float: 1 ifloat: 1 -Test "tgamma (0x1p-53) == 9.0071992547409914227843350984672492007618e+15": +Test "tgamma (0x1p-53)": double: 1 idouble: 1 -Test "tgamma (0x1p-64) == 1.8446744073709551615422784335098467139447e+19": +Test "tgamma (0x1p-64)": ildouble: 1 ldouble: 1 -Test "tgamma (0x2.0000000000002p0) == 1.0000000000000001877539613108624482361963e+00": +Test "tgamma (0x2.0000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x2.000004p0) == 1.0000001007996638509889062631687945799175e+00": +Test "tgamma (0x2.000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x2.30a43cp+4) == 3.4027979115654976101247558405326779640190e+38": +Test "tgamma (0x2.30a43cp+4)": double: 1 idouble: 1 -Test "tgamma (0x2.fffffcp0) == 1.9999995599822108706107786027549565954046e+00": +Test "tgamma (0x2.fffffcp0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (0x2.ffffffffffffep0) == 1.9999999999999991804028675282128956223990e+00": +Test "tgamma (0x2.ffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x3.0000000000002p0) == 2.0000000000000008195971324717875960213536e+00": +Test "tgamma (0x3.0000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x3.fffffcp0) == 5.9999982031095793171233994481968816873643e+00": +Test "tgamma (0x3.fffffcp0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x3.fffffffffffffffcp0) == 5.9999999999999999983657373939865784753909e+00": +Test "tgamma (0x3.fffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x4.0000000000000008p0) == 6.0000000000000000032685252120268430507939e+00": +Test "tgamma (0x4.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x4.000008p0) == 6.0000035937827461765660468073471093546129e+00": +Test "tgamma (0x4.000008p0)": float: 1 ifloat: 1 -Test "tgamma (0x4.fffff8p0) == 2.3999982763857938712639837029547357501709e+01": +Test "tgamma (0x4.fffff8p0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x4.fffffffffffffff8p0) == 2.3999999999999999984323813937927417165027e+01": +Test "tgamma (0x4.fffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x5.0000000000000008p0) == 2.4000000000000000015676186062072582846211e+01": +Test "tgamma (0x5.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x5.000008p0) == 2.4000017236155647574166073485628713443799e+01": +Test "tgamma (0x5.000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x5.fffff8p0) == 1.1999990237520611552119807476573441975106e+02": +Test "tgamma (0x5.fffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x5.ffffffffffffcp0) == 1.1999999999999981815957265157389249327533e+02": +Test "tgamma (0x5.ffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x6.0000000000000008p0) == 1.2000000000000000008878927116622375680433e+02": +Test "tgamma (0x6.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x6.000008p0) == 1.2000009762487825358530770343720418162783e+02": +Test "tgamma (0x6.000008p0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x6.fffff8p0) == 7.1999935703082425988147448928288557689866e+02": +Test "tgamma (0x6.fffff8p0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x6.ffffffffffffcp0) == 7.1999999999999880237602554542848858572672e+02": +Test "tgamma (0x6.ffffffffffffcp0)": double: 3 idouble: 3 -Test "tgamma (0x7.0000000000000008p0) == 7.2000000000000000058477733127664675369681e+02": +Test "tgamma (0x7.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x7.0000000000004p0) == 7.2000000000000119762397445457359071259652e+02": +Test "tgamma (0x7.0000000000004p0)": double: 4 idouble: 4 ildouble: 1 ldouble: 1 -Test "tgamma (0x7.000008p0) == 7.2000064296977505705636258629805621178587e+02": +Test "tgamma (0x7.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x7.fffff8p0) == 5.0399951558933225045148935487583089307135e+03": +Test "tgamma (0x7.fffff8p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x7.ffffffffffffcp0) == 5.0399999999999909771437166339103165198442e+03": +Test "tgamma (0x7.ffffffffffffcp0)": double: 2 idouble: 2 -Test "tgamma (0x7.fffffffffffffff8p0) == 5.0399999999999999955943084553876474508520e+03": +Test "tgamma (0x7.fffffffffffffff8p0)": ildouble: 3 ldouble: 3 -Test "tgamma (0x8.000000000000001p0) == 5.0400000000000000088113830892247051102283e+03": +Test "tgamma (0x8.000000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x8.0000000000008p0) == 5.0400000000000180457125667322294144477136e+03": +Test "tgamma (0x8.0000000000008p0)": double: 1 idouble: 1 -Test "tgamma (0x8.00001p0) == 5.0400096882277802019946778420223050233915e+03": +Test "tgamma (0x8.00001p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0xa.b9fd72b0fb238p+4) == 1.7976931348622298700886249281842651388250e+308": +Test "tgamma (0xa.b9fd72b0fb238p+4)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tgamma (10) == 362880": +Test "tgamma (10)": double: 1 idouble: 1 -Test "tgamma (18.5) == 1.4986120533153361177371791123515513270334e+15": +Test "tgamma (18.5)": ildouble: 1 ldouble: 1 -Test "tgamma (19.5) == 2.7724322986333718178137813578503699550119e+16": +Test "tgamma (19.5)": double: 1 idouble: 1 -Test "tgamma (2.5) == 1.3293403881791370204736256125058588870982e+00": +Test "tgamma (2.5)": float: 1 ifloat: 1 -Test "tgamma (23.5) == 5.3613035875444147334274983856108155717836e+21": +Test "tgamma (23.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (29.5) == 1.6348125198274266444378807806868221866931e+30": +Test "tgamma (29.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (3) == 2": +Test "tgamma (3)": float: 1 ifloat: 1 -Test "tgamma (3.5) == 3.3233509704478425511840640312646472177454e+00": +Test "tgamma (3.5)": float: 1 ifloat: 1 -Test "tgamma (30.5) == 4.8226969334909086010917483030261254507447e+31": +Test "tgamma (30.5)": float: 1 ifloat: 1 -Test "tgamma (31.5) == 1.4709225647147271233329832324229682624771e+33": +Test "tgamma (31.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (32.5) == 4.6334060788513904384988971821323500268029e+34": +Test "tgamma (32.5)": ildouble: 1 ldouble: 1 -Test "tgamma (34.5) == 5.0446208683494513399156743070465960916817e+37": +Test "tgamma (34.5)": ildouble: 1 ldouble: 1 -Test "tgamma (4) == 6": +Test "tgamma (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (4.5) == 1.1631728396567448929144224109426265262109e+01": +Test "tgamma (4.5)": double: 1 idouble: 1 -Test "tgamma (5.5) == 5.2342777784553520181149008492418193679490e+01": +Test "tgamma (5.5)": ildouble: 1 ldouble: 1 -Test "tgamma (6.5) == 2.8788527781504436099631954670830006523720e+02": +Test "tgamma (6.5)": ildouble: 1 ldouble: 1 -Test "tgamma (7.5) == 1.8712543057977883464760770536039504240418e+03": +Test "tgamma (7.5)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (8) == 5040": +Test "tgamma (8)": ildouble: 1 ldouble: 1 -Test "tgamma (8.5) == 1.4034407293483412598570577902029628180313e+04": +Test "tgamma (8.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tgamma (9) == 40320": +Test "tgamma (9)": ildouble: 1 ldouble: 1 -Test "tgamma (9.5) == 1.1929246199460900708784991216725183953266e+05": +Test "tgamma (9.5)": double: 1 float: 1 idouble: 1 @@ -6766,67 +6781,67 @@ ildouble: 1 ldouble: 1 # y0 -Test "y0 (0.125) == -1.38968062514384052915582277745018693": +Test "y0 (0.125)": ildouble: 1 ldouble: 1 -Test "y0 (0.75) == -0.137172769385772397522814379396581855": +Test "y0 (0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": ildouble: 1 ldouble: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-60) == -2.6550076313426878432849115782108205929120e+1": +Test "y0 (0x1p-60)": double: 1 idouble: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 idouble: 1 -Test "y0 (0x1p16382) == 8.0839224448726336195866026476176740513439e-2467": +Test "y0 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -6835,44 +6850,44 @@ ildouble: 1 ldouble: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.001000001p+593) == 3.927269966354206207832593635798954916263e-90": +Test "y1 (0x1.001000001p+593)": ildouble: 2 ldouble: 2 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": float: 1 ifloat: 1 -Test "y1 (0x1p1023) == 1.5665258060609012834424478437196679802783e-155": +Test "y1 (0x1p1023)": double: 1 idouble: 1 -Test "y1 (0x1p16382) == 1.2193782500509000574176799046642541129387e-2466": +Test "y1 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "y1 (1.0) == -0.781212821300288716547150000047964821": +Test "y1 (1.0)": double: 1 idouble: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 @@ -6881,108 +6896,108 @@ ildouble: 1 ldouble: 1 # yn -Test "yn (0, 0.125) == -1.38968062514384052915582277745018693": +Test "yn (0, 0.125)": ildouble: 1 ldouble: 1 -Test "yn (0, 0.75) == -0.137172769385772397522814379396581855": +Test "yn (0, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": ildouble: 1 ldouble: 1 -Test "yn (1, 1.0) == -0.781212821300288716547150000047964821": +Test "yn (1, 1.0)": double: 1 idouble: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": float: 2 ifloat: 2 ildouble: 4 ldouble: 4 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 2 float: 3 idouble: 2 ifloat: 3 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 float: 3 idouble: 2 ifloat: 3 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": ildouble: 1 ldouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 float: 1 idouble: 1 @@ -7506,7 +7521,9 @@ ldouble: 1 Function: "gamma": double: 1 +float: 2 idouble: 1 +ifloat: 2 ildouble: 1 ldouble: 1 @@ -7560,6 +7577,10 @@ Function: "pow": ildouble: 1 ldouble: 1 +Function: "pow10": +ildouble: 1 +ldouble: 1 + Function: "pow_downward": double: 1 float: 1 diff --git a/libc/sysdeps/ieee754/dbl-64/s_nearbyint.c b/libc/sysdeps/ieee754/dbl-64/s_nearbyint.c index eb40c298b..5017f471d 100644 --- a/libc/sysdeps/ieee754/dbl-64/s_nearbyint.c +++ b/libc/sysdeps/ieee754/dbl-64/s_nearbyint.c @@ -47,6 +47,7 @@ double __nearbyint(double x) libc_feholdexcept (&env); w = TWO52[sx]+x; t = w-TWO52[sx]; + math_force_eval (t); libc_fesetenv (&env); GET_HIGH_WORD(i0,t); SET_HIGH_WORD(t,(i0&0x7fffffff)|(sx<<31)); @@ -59,6 +60,7 @@ double __nearbyint(double x) libc_feholdexcept (&env); w = TWO52[sx]+x; t = w-TWO52[sx]; + math_force_eval (t); libc_fesetenv (&env); return t; } diff --git a/libc/sysdeps/ieee754/flt-32/s_nearbyintf.c b/libc/sysdeps/ieee754/flt-32/s_nearbyintf.c index 48debadde..5aebefafc 100644 --- a/libc/sysdeps/ieee754/flt-32/s_nearbyintf.c +++ b/libc/sysdeps/ieee754/flt-32/s_nearbyintf.c @@ -39,6 +39,7 @@ __nearbyintf(float x) libc_feholdexceptf (&env); w = TWO23[sx]+x; t = w-TWO23[sx]; + math_force_eval (t); libc_fesetenvf (&env); GET_FLOAT_WORD(i0,t); SET_FLOAT_WORD(t,(i0&0x7fffffff)|(sx<<31)); @@ -51,6 +52,7 @@ __nearbyintf(float x) libc_feholdexceptf (&env); w = TWO23[sx]+x; t = w-TWO23[sx]; + math_force_eval (t); libc_fesetenvf (&env); return t; } diff --git a/libc/sysdeps/ieee754/ldbl-128/s_nearbyintl.c b/libc/sysdeps/ieee754/ldbl-128/s_nearbyintl.c index d2afc10a5..2017c0420 100644 --- a/libc/sysdeps/ieee754/ldbl-128/s_nearbyintl.c +++ b/libc/sysdeps/ieee754/ldbl-128/s_nearbyintl.c @@ -47,6 +47,7 @@ long double __nearbyintl(long double x) feholdexcept (&env); w = TWO112[sx]+x; t = w-TWO112[sx]; + math_force_eval (t); fesetenv (&env); GET_LDOUBLE_MSW64(i0,t); SET_LDOUBLE_MSW64(t,(i0&0x7fffffffffffffffLL)|(sx<<63)); @@ -59,6 +60,7 @@ long double __nearbyintl(long double x) feholdexcept (&env); w = TWO112[sx]+x; t = w-TWO112[sx]; + math_force_eval (t); fesetenv (&env); return t; } diff --git a/libc/sysdeps/ieee754/ldbl-128ibm/s_nearbyintl.c b/libc/sysdeps/ieee754/ldbl-128ibm/s_nearbyintl.c index b654bf586..bfcd11044 100644 --- a/libc/sysdeps/ieee754/ldbl-128ibm/s_nearbyintl.c +++ b/libc/sysdeps/ieee754/ldbl-128ibm/s_nearbyintl.c @@ -21,6 +21,7 @@ when it's coded in C. */ #include <math.h> +#include <math_private.h> #include <fenv.h> #include <math_ldbl_opt.h> #include <float.h> @@ -53,6 +54,8 @@ __nearbyintl (long double x) } u.dd[0] = high; u.dd[1] = 0.0; + math_force_eval (u.dd[0]); + math_force_eval (u.dd[1]); fesetenv (&env); } else if (fabs (u.dd[1]) < TWO52 && u.dd[1] != 0.0) @@ -109,6 +112,8 @@ __nearbyintl (long double x) } u.dd[0] = high + low; u.dd[1] = high - u.dd[0] + low; + math_force_eval (u.dd[0]); + math_force_eval (u.dd[1]); fesetenv (&env); } diff --git a/libc/sysdeps/ieee754/ldbl-96/e_hypotl.c b/libc/sysdeps/ieee754/ldbl-96/e_hypotl.c index 306f92924..789548884 100644 --- a/libc/sysdeps/ieee754/ldbl-96/e_hypotl.c +++ b/libc/sysdeps/ieee754/ldbl-96/e_hypotl.c @@ -85,7 +85,7 @@ long double __ieee754_hypotl(long double x, long double y) u_int32_t high,low; GET_LDOUBLE_WORDS(exp,high,low,b); if((high|low)==0) return a; - SET_LDOUBLE_WORDS(t1, 0x7ffd, 0, 0); /* t1=2^16382 */ + SET_LDOUBLE_WORDS(t1, 0x7ffd, 0x80000000, 0); /* t1=2^16382 */ b *= t1; a *= t1; k -= 16382; diff --git a/libc/sysdeps/ieee754/ldbl-96/s_nearbyintl.c b/libc/sysdeps/ieee754/ldbl-96/s_nearbyintl.c index ed9836c87..c1d77f0c0 100644 --- a/libc/sysdeps/ieee754/ldbl-96/s_nearbyintl.c +++ b/libc/sysdeps/ieee754/ldbl-96/s_nearbyintl.c @@ -54,6 +54,7 @@ long double __nearbyintl(long double x) feholdexcept (&env); w = TWO63[sx]+x; t = w-TWO63[sx]; + math_force_eval (t); fesetenv (&env); GET_LDOUBLE_EXP(i0,t); SET_LDOUBLE_EXP(t,(i0&0x7fff)|(sx<<15)); @@ -80,6 +81,7 @@ long double __nearbyintl(long double x) feholdexcept (&env); w = TWO63[sx]+x; t = w-TWO63[sx]; + math_force_eval (t); fesetenv (&env); return t; } diff --git a/libc/sysdeps/mach/hurd/dl-sysdep.c b/libc/sysdeps/mach/hurd/dl-sysdep.c index c9ab66114..94b6d094a 100644 --- a/libc/sysdeps/mach/hurd/dl-sysdep.c +++ b/libc/sysdeps/mach/hurd/dl-sysdep.c @@ -123,7 +123,6 @@ _dl_sysdep_start (void **start_argptr, { void go (intptr_t *argdata) { - extern unsigned int _dl_skip_args; /* rtld.c */ char **p; /* Cache the information in various global variables. */ diff --git a/libc/sysdeps/mach/hurd/i386/init-first.c b/libc/sysdeps/mach/hurd/i386/init-first.c index fc3330c1f..70378d806 100644 --- a/libc/sysdeps/mach/hurd/i386/init-first.c +++ b/libc/sysdeps/mach/hurd/i386/init-first.c @@ -36,9 +36,6 @@ extern void __init_misc (int, char **, char **); #ifdef USE_NONOPTION_FLAGS extern void __getopt_clean_environment (char **); #endif -#ifndef SHARED -extern void _dl_non_dynamic_init (void) internal_function; -#endif extern void __libc_global_ctors (void); unsigned int __hurd_threadvar_max; diff --git a/libc/sysdeps/posix/getaddrinfo.c b/libc/sysdeps/posix/getaddrinfo.c index ab135ada7..7bb3ded9a 100644 --- a/libc/sysdeps/posix/getaddrinfo.c +++ b/libc/sysdeps/posix/getaddrinfo.c @@ -1036,7 +1036,15 @@ gaih_inet (const char *name, const struct gaih_service *service, } } else - status = NSS_STATUS_UNAVAIL; + { + status = NSS_STATUS_UNAVAIL; + /* Could not load any of the lookup functions. Indicate + an internal error if the failure was due to a system + error other than the file not being found. We use the + errno from the last failed callback. */ + if (errno != 0 && errno != ENOENT) + __set_h_errno (NETDB_INTERNAL); + } } if (nss_next_action (nip, status) == NSS_ACTION_RETURN) @@ -1050,7 +1058,7 @@ gaih_inet (const char *name, const struct gaih_service *service, _res.options |= old_res_options & RES_USE_INET6; - if (status == NSS_STATUS_UNAVAIL) + if (h_errno == NETDB_INTERNAL) { result = GAIH_OKIFUNSPEC | -EAI_SYSTEM; goto free_and_return; diff --git a/libc/sysdeps/powerpc/fpu/Makefile b/libc/sysdeps/powerpc/fpu/Makefile index fda59f9fa..53470a9cf 100644 --- a/libc/sysdeps/powerpc/fpu/Makefile +++ b/libc/sysdeps/powerpc/fpu/Makefile @@ -1,8 +1,5 @@ ifeq ($(subdir),math) libm-support += fenv_const fe_nomask fe_mask t_sqrt - -# libm needs ld.so to access dl_hwcap -$(objpfx)libm.so: $(elfobjdir)/ld.so endif ifeq ($(subdir),stdlib) diff --git a/libc/sysdeps/powerpc/fpu/libm-test-ulps b/libc/sysdeps/powerpc/fpu/libm-test-ulps index 18927b470..5475b51ca 100644 --- a/libc/sysdeps/powerpc/fpu/libm-test-ulps +++ b/libc/sysdeps/powerpc/fpu/libm-test-ulps @@ -1,32 +1,32 @@ # Begin of automatic generation # acos -Test "acos (-0x0.ffffffff8p0) == 3.1415773948007305904329067627145550395696": +Test "acos (-0x0.ffffffff8p0)": ildouble: 1 ldouble: 1 -Test "acos (-0x0.ffffffp0) == 3.1412473866050770348750401337968641476999": +Test "acos (-0x0.ffffffp0)": ildouble: 1 ldouble: 1 -Test "acos (2e-17) == 1.57079632679489659923132169163975144": +Test "acos (2e-17)": ildouble: 1 ldouble: 1 # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 @@ -35,21 +35,21 @@ ildouble: 1 ldouble: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 @@ -58,5038 +58,5038 @@ ildouble: 1 ldouble: 1 # acos_upward -Test "acos_upward (-0) == pi/2": +Test "acos_upward (-0)": ildouble: 2 ldouble: 2 -Test "acos_upward (-1) == pi": +Test "acos_upward (-1)": ildouble: 2 ldouble: 2 -Test "acos_upward (0) == pi/2": +Test "acos_upward (0)": ildouble: 2 ldouble: 2 # asin -Test "asin (-0x0.ffffffff8p0) == -1.5707810680058339712015850710748035974710": +Test "asin (-0x0.ffffffff8p0)": ildouble: 1 ldouble: 1 -Test "asin (-0x0.ffffffp0) == -1.5704510598101804156437184421571127056013": +Test "asin (-0x0.ffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (0.75) == 0.848062078981481008052944338998418080": +Test "asin (0.75)": ildouble: 2 ldouble: 2 -Test "asin (0x0.ffffffff8p0) == 1.5707810680058339712015850710748035974710": +Test "asin (0x0.ffffffff8p0)": ildouble: 1 ldouble: 1 -Test "asin (0x0.ffffffp0) == 1.5704510598101804156437184421571127056013": +Test "asin (0x0.ffffffp0)": ildouble: 1 ldouble: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (-1.0) == -pi/2": +Test "asin_downward (-1.0)": ildouble: 1 ldouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 # asin_upward -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 -Test "asin_upward (1.0) == pi/2": +Test "asin_upward (1.0)": ildouble: 1 ldouble: 1 # atan2 -Test "atan2 (-0.00756827042671106339, -.001792735857538728036) == -1.80338464113663849327153994379639112": +Test "atan2 (-0.00756827042671106339, -.001792735857538728036)": ildouble: 1 ldouble: 1 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cabs -Test "cabs (-0.75 + 12.390625 i) == 12.4133028598606664302388810868156657": +Test "cabs (-0.75 + 12.390625 i)": float: 1 ifloat: 1 -Test "cabs (-0.75 - 12.390625 i) == 12.4133028598606664302388810868156657": +Test "cabs (-0.75 - 12.390625 i)": float: 1 ifloat: 1 -Test "cabs (-12.390625 + 0.75 i) == 12.4133028598606664302388810868156657": +Test "cabs (-12.390625 + 0.75 i)": float: 1 ifloat: 1 -Test "cabs (-12.390625 - 0.75 i) == 12.4133028598606664302388810868156657": +Test "cabs (-12.390625 - 0.75 i)": float: 1 ifloat: 1 -Test "cabs (0.75 + 1.25 i) == 1.45773797371132511771853821938639577": +Test "cabs (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cabs (0.75 + 12.390625 i) == 12.4133028598606664302388810868156657": +Test "cabs (0.75 + 12.390625 i)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x1.000000000000000000000000008p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x1.000000000000000000000000008p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (-0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (-0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + +0 i) == 2.094395102393195492308428922186335256131 - 0 i": +Test "Real part of: cacos (-0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 0x1.fp-1025 i) == 2.094395102393195492308428922186335256131 - 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 - 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 + 0x1p-105 i) == 2.094395102393195492308428922186335256131 - 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (-0.5 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-105 i) == 2.094395102393195492308428922186335256131 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 + 0x1p-112 i) == 2.094395102393195492308428922186335256131 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (-0.5 + 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-112 i) == 2.094395102393195492308428922186335256131 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 + 0x1p-23 i) == 2.094395102393190022547898764614298351924 - 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: cacos (-0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i) == 2.094395102393190022547898764614298351924 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 + 0x1p-52 i) == 2.094395102393195492308428922186316279087 - 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (-0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-52 i) == 2.094395102393195492308428922186316279087 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 0x1p-63 i) == 2.094395102393195492308428922186335256127 - 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (-0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0 i) == 2.094395102393195492308428922186335256131 + +0 i": +Test "Real part of: cacos (-0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0x1.fp-1025 i) == 2.094395102393195492308428922186335256131 + 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 + 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 - 0x1p-105 i) == 2.094395102393195492308428922186335256131 + 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (-0.5 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-105 i) == 2.094395102393195492308428922186335256131 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 - 0x1p-112 i) == 2.094395102393195492308428922186335256131 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (-0.5 - 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-112 i) == 2.094395102393195492308428922186335256131 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 - 0x1p-23 i) == 2.094395102393190022547898764614298351924 + 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: cacos (-0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i) == 2.094395102393190022547898764614298351924 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 - 0x1p-52 i) == 2.094395102393195492308428922186316279087 + 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (-0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-52 i) == 2.094395102393195492308428922186316279087 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0x1p-63 i) == 2.094395102393195492308428922186335256127 + 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (-0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 3.141592634635223399311902261000251614142 - 1.171456840272878582596796205397918831268e-8 i": +Test "Real part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 3.141592634635223399311902261000251614142 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 3.141592634635223399311902261000251614142 + 1.171456840272878582596796205397918831268e-8 i": +Test "Real part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 3.141592634635223399311902261000251614142 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == 3.141592653170952461345846619605307690007 - 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == 3.141592653170952461345846619605307690007 + 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x0.ffffffp0 + 0.0 i) == 3.141247386605077034875040133796864147700 - 0.0 i": +Test "Real part of: cacos (-0x0.ffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x0.ffffffp0 + 0x1.fp-129 i) == 3.141247386605077034875040133796864147700 - 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (-0x0.ffffffp0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i) == 3.141153467203602189751698864505105063797 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (-0x0.ffffffp0 - 0.0 i) == 3.141247386605077034875040133796864147700 + 0.0 i": +Test "Real part of: cacos (-0x0.ffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x0.ffffffp0 - 0x1.fp-129 i) == 3.141247386605077034875040133796864147700 + 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (-0x0.ffffffp0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i) == 3.141153467203602189751698864505105063797 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (-0x1.0000000000000002p0 + 0x1p-63 i) == 3.141592653377875508152537040020250564229 - 5.116146586219826555037807251857670783420e-10 i": +Test "Real part of: cacos (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.0000000000000002p0 - 0x1p-63 i) == 3.141592653377875508152537040020250564229 + 5.116146586219826555037807251857670783420e-10 i": +Test "Real part of: cacos (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.0000000000001p0 + 0x1p-52 i) == 3.141592643999491532482601997450598791535 - 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1p-52 i) == 3.141592643999491532482601997450598791535 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.0000000000001p0 - 0x1p-52 i) == 3.141592643999491532482601997450598791535 + 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1p-52 i) == 3.141592643999491532482601997450598791535 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.000002p0 + 0x1p-23 i) == 3.141370441751352383825802745874586120521 - 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (-0x1.000002p0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.000002p0 + 0x1p-23 i) == 3.141370441751352383825802745874586120521 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cacos (-0x1.000002p0 - 0x1p-23 i) == 3.141370441751352383825802745874586120521 + 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (-0x1.000002p0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.000002p0 - 0x1p-23 i) == 3.141370441751352383825802745874586120521 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i) == 1.572134236154454360143880041170803681211 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i) == 1.572134236154454360143880041170803681211 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691640832196834 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-100 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691640832196834 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691640832196834 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-100 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691640832196834 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 0x1.000000000000000000000000008p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 0x1.000000000000000000000000008p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442101 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442101 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x0.ffffffp0 i) == 1.570796326794896619231321691639751442101 - 8.813735448726938863015878255140556727969e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 - 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1.fp-129 i) == 1.570796326794896619231321691639751442101 - 2.846900380897727558361783801085126250967e-39 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1p-23 i) == 1.570796326794896619231321691639751442101 - 1.192092895507809676556842485683592032154e-7 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442101 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442101 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1.fp-129 + 1.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442101 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442101 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x0.ffffffp0 i) == 1.570796326794896619231321691639751442101 + 8.813735448726938863015878255140556727969e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 + 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1.fp-129 i) == 1.570796326794896619231321691639751442101 + 2.846900380897727558361783801085126250967e-39 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1p-23 i) == 1.570796326794896619231321691639751442101 + 1.192092895507809676556842485683592032154e-7 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442101 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442101 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1.fp-129 - 1.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1.fp-30 + 1.0 i) == 1.570796328070826603447840231892468927106 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: cacos (-0x1.fp-30 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i) == 1.570796328070826603447840231892468927106 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-30 - 1.0 i) == 1.570796328070826603447840231892468927106 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: cacos (-0x1.fp-30 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i) == 1.570796328070826603447840231892468927106 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 + 0.0 i) == 1.570796326794896619231321691639776094002 - 0.0 i": +Test "Real part of: cacos (-0x1p-105 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 + 0.5 i) == 1.570796326794896619231321691639773491431 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i) == 1.570796326794896619231321691639773491431 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639768873627 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-105 + 0x1p-105 i) == 1.570796326794896619231321691639776094002 - 2.465190328815661891911651766508706967729e-32 i": +Test "Real part of: cacos (-0x1p-105 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 - 0.0 i) == 1.570796326794896619231321691639776094002 + 0.0 i": +Test "Real part of: cacos (-0x1p-105 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 - 0.5 i) == 1.570796326794896619231321691639773491431 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i) == 1.570796326794896619231321691639773491431 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639768873627 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-105 - 0x1p-105 i) == 1.570796326794896619231321691639776094002 + 2.465190328815661891911651766508706967729e-32 i": +Test "Real part of: cacos (-0x1p-105 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0.0 i) == 1.570796326794896619231321691639751634692 - 0.0 i": +Test "Real part of: cacos (-0x1p-112 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751614359 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751614359 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0x1p-112 i) == 1.570796326794896619231321691639751634692 - 1.925929944387235853055977942584927318538e-34 i": +Test "Real part of: cacos (-0x1p-112 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0.0 i) == 1.570796326794896619231321691639751634692 + 0.0 i": +Test "Real part of: cacos (-0x1p-112 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751614359 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751614359 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0x1p-112 i) == 1.570796326794896619231321691639751634692 + 1.925929944387235853055977942584927318538e-34 i": +Test "Real part of: cacos (-0x1p-112 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 + 0.0 i) == 1.570796446004186170012854035955502877351 - 0.0 i": +Test "Real part of: cacos (-0x1p-23 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 + 0.5 i) == 1.570796433418926613232299739606181733819 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: cacos (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i) == 1.570796433418926613232299739606181733819 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0x1.000002p0 i) == 1.570796411088588616723617301287646121905 - 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-23 + 0x1.fp-129 i) == 1.570796446004186170012854035955502877351 - 2.846900380897747786805634596726756660388e-39 i": +Test "Real part of: cacos (-0x1p-23 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 + 0x1p-23 i) == 1.570796446004186170012007003008248567984 - 1.192092895507818146886315028596704749235e-7 i": +Test "Real part of: cacos (-0x1p-23 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 - 0.0 i) == 1.570796446004186170012854035955502877351 + 0.0 i": +Test "Real part of: cacos (-0x1p-23 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 - 0.5 i) == 1.570796433418926613232299739606181733819 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: cacos (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i) == 1.570796433418926613232299739606181733819 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0x1.000002p0 i) == 1.570796411088588616723617301287646121905 + 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-23 - 0x1.fp-129 i) == 1.570796446004186170012854035955502877351 + 2.846900380897747786805634596726756660388e-39 i": +Test "Real part of: cacos (-0x1p-23 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 - 0x1p-23 i) == 1.570796446004186170012007003008248567984 + 1.192092895507818146886315028596704749235e-7 i": +Test "Real part of: cacos (-0x1p-23 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 + 0.0 i) == 1.570796326794896841275926616671059526825 - 0.0 i": +Test "Real part of: cacos (-0x1p-52 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 + 0.5 i) == 1.570796326794896817834053951421591208280 - 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: cacos (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i) == 1.570796326794896817834053951421591208280 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 + 0x1p-52 i) == 1.570796326794896841275926616671059526825 - 2.220446049250313080847263336181677117148e-16 i": +Test "Real part of: cacos (-0x1p-52 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 - 0.0 i) == 1.570796326794896841275926616671059526825 + 0.0 i": +Test "Real part of: cacos (-0x1p-52 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 - 0.5 i) == 1.570796326794896817834053951421591208280 + 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: cacos (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i) == 1.570796326794896817834053951421591208280 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 - 0x1p-52 i) == 1.570796326794896841275926616671059526825 + 2.220446049250313080847263336181677117148e-16 i": +Test "Real part of: cacos (-0x1p-52 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 + 0.0 i) == 1.570796326794896619339741908888301885499 - 0.0 i": +Test "Real part of: cacos (-0x1p-63 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 + 0.5 i) == 1.570796326794896619328295682000973043547 - 4.812118250596034474977589134243684231373e-1 i": +Test "Real part of: cacos (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i) == 1.570796326794896619328295682000973043547 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 + 0x1p-63 i) == 1.570796326794896619339741908888301885499 - 1.084202172485504434007452800869941711430e-19 i": +Test "Real part of: cacos (-0x1p-63 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 - 0.0 i) == 1.570796326794896619339741908888301885499 + 0.0 i": +Test "Real part of: cacos (-0x1p-63 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 - 0.5 i) == 1.570796326794896619328295682000973043547 + 4.812118250596034474977589134243684231373e-1 i": +Test "Real part of: cacos (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i) == 1.570796326794896619328295682000973043547 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 - 0x1p-63 i) == 1.570796326794896619339741908888301885499 + 1.084202172485504434007452800869941711430e-19 i": +Test "Real part of: cacos (-0x1p-63 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-1.0 + 0.5 i) == 2.466703808003786858297978415967328452322 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (-1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 + 0.5 i) == 2.466703808003786858297978415967328452322 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 + 0x1.fp-100 i) == 3.141592653589792002170605123018614219682 - 1.236292038260260888664514866457202186027e-15 i": +Test "Real part of: cacos (-1.0 + 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 + 0x1p50 i) == 1.570796326794897507409741391764983781004 - 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-1.0 + 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-1.0 - 0.5 i) == 2.466703808003786858297978415967328452322 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (-1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 - 0.5 i) == 2.466703808003786858297978415967328452322 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 - 0x1.fp-100 i) == 3.141592653589792002170605123018614219682 + 1.236292038260260888664514866457202186027e-15 i": +Test "Real part of: cacos (-1.0 - 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 - 0x1p50 i) == 1.570796326794897507409741391764983781004 + 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-1.0 - 0x1p50 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-2 - 3 i) == 2.1414491111159960199416055713254211 + 1.9833870299165354323470769028940395 i": +Test "Real part of: cacos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.0 + 0x1.000000000000000000000000008p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x1.000000000000000000000000008p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.25 + 1.0 i) == 1.394493894017929688812643125003661339452 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.25 - 1.0 i) == 1.394493894017929688812643125003661339452 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 - 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-105 i) == 1.047197551196597746154214461093167628066 - 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-105 i) == 1.047197551196597746154214461093167628066 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-112 i) == 1.047197551196597746154214461093167628066 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-112 i) == 1.047197551196597746154214461093167628066 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-23 i) == 1.047197551196603215914744618665204532273 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-52 i) == 1.047197551196597746154214461093186605110 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-63 i) == 1.047197551196597746154214461093167628070 - 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 + 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 1.0 i) == 1.221357263937683325603909865564381489366 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.5 + 1.0 i) == 1.221357263937683325603909865564381489366 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 + 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-105 i) == 1.047197551196597746154214461093167628066 + 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-105 i) == 1.047197551196597746154214461093167628066 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-112 i) == 1.047197551196597746154214461093167628066 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-112 i) == 1.047197551196597746154214461093167628066 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-23 i) == 1.047197551196603215914744618665204532273 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-52 i) == 1.047197551196597746154214461093186605110 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-63 i) == 1.047197551196597746154214461093167628070 + 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 - 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 1.0 i) == 1.221357263937683325603909865564381489366 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.5 - 1.0 i) == 1.221357263937683325603909865564381489366 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Real part of: cacos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0.0 i) == 1.490116119384765638786343542550461592240e-8 - 0.0 i": +Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0.0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0x1.fp-1025 i) == 1.490116119384765638786343542550461592240e-8 - 3.616396521699973256461764099945789620604e-301 i": +Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0.0 i) == 1.490116119384765638786343542550461592240e-8 + 0.0 i": +Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0.0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0x1.fp-1025 i) == 1.490116119384765638786343542550461592240e-8 + 3.616396521699973256461764099945789620604e-301 i": +Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == 1.997188458999618357060632049675702684031e-16 - 1.234330349600789959989661887846005659983e-16 i": +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == 1.997188458999618357060632049675702684031e-16 + 1.234330349600789959989661887846005659983e-16 i": +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i) == 3.452669847162035876032494826387364972849e-4 - 0.0 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i) == 3.452669847162035876032494826387364972849e-4 - 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i) == 3.452669847162035876032494826387364972849e-4 + 0.0 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i) == 3.452669847162035876032494826387364972849e-4 + 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 - 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 + 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 - 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x1.000002p0 + 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 + 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x1.000002p0 - 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cacos (0x1.fp-10 + 1.0 i) == 1.569458417435338878318763342108699202986 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: cacos (0x1.fp-10 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i) == 1.569458417435338878318763342108699202986 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.fp-10 - 1.0 i) == 1.569458417435338878318763342108699202986 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: cacos (0x1.fp-10 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i) == 1.569458417435338878318763342108699202986 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691638670687364 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (0x1.fp-100 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691638670687364 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691638670687364 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (0x1.fp-100 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691638670687364 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 0x1.000000000000000000000000008p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 0x1.000000000000000000000000008p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442096 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442097 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442097 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442096 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442097 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442097 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i) == 1.570796325518966635014803151387033957091 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i) == 1.570796325518966635014803151387033957091 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 - 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 - 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-105 + 0.5 i) == 1.570796326794896619231321691639729392766 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (0x1p-105 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-105 + 0.5 i) == 1.570796326794896619231321691639729392766 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639734010571 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-105 - 0.5 i) == 1.570796326794896619231321691639729392766 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (0x1p-105 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-105 - 0.5 i) == 1.570796326794896619231321691639729392766 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639734010571 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751269838 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751269838 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0.5 i) == 1.570796220170866625230343643673321150378 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0x1.000002p0 i) == 1.570796242501204621739026081991856762292 - 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0.5 i) == 1.570796220170866625230343643673321150378 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0x1.000002p0 i) == 1.570796242501204621739026081991856762292 + 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 + 0.5 i) == 1.570796326794896420628589431857911675917 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.570796326794896462222075823262236786996 - 8.813735870195429467279863907910458761820e-1 i": +Test "Real part of: cacos (0x1p-52 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-52 + 0x1.0000000000001p0 i) == 1.570796326794896462222075823262262934288 - 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: cacos (0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 - 0.5 i) == 1.570796326794896420628589431857911675917 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.570796326794896462222075823262236786996 + 8.813735870195429467279863907910458761820e-1 i": +Test "Real part of: cacos (0x1p-52 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-52 - 0x1.0000000000001p0 i) == 1.570796326794896462222075823262262934288 + 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: cacos (0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0.5 i) == 1.570796326794896619134347701278529840650 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0.5 i) == 1.570796326794896619134347701278529840650 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (1.0 + 0.25 i) == 4.890443302710802929202843732146540079124e-1 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: cacos (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 + 0x1.fp-10 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 - 4.247867098745151888768727039216644758847e-5 i": +Test "Real part of: cacos (1.0 + 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Real part of: cacos (1.0 - 0.25 i) == 4.890443302710802929202843732146540079124e-1 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: cacos (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 - 0x1.fp-10 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 + 4.247867098745151888768727039216644758847e-5 i": +Test "Real part of: cacos (1.0 - 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.0 + 0x1.000000000000000000000000008p0 i) == 8.813735870195430252326093249798097405561e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x1.000000000000000000000000008p0 i) == 8.813735870195430252326093249798097405561e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Real part of: cacosh (-0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Real part of: cacosh (-0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 2.094395102393190022547898764614298351924 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 2.094395102393195492308428922186316279087 i": +Test "Real part of: cacosh (-0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 2.094395102393195492308428922186316279087 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 + 2.094395102393195492308428922186335256127 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Imaginary part of: cacosh (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 2.094395102393190022547898764614298351924 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 2.094395102393195492308428922186316279087 i": +Test "Real part of: cacosh (-0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 2.094395102393195492308428922186316279087 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 - 2.094395102393195492308428922186335256127 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Imaginary part of: cacosh (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 3.141592634635223399311902261000251614142 i": +Test "Imaginary part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 3.141592634635223399311902261000251614142 i": +Test "Imaginary part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 3.141592653170952461345846619605307690007 i": +Test "Imaginary part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 3.141592653170952461345846619605307690007 i": +Test "Imaginary part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x0.ffffffp0 + 0.0 i) == 0.0 + 3.141247386605077034875040133796864147700 i": +Test "Imaginary part of: cacosh (-0x0.ffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x0.ffffffp0 + 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 + 3.141247386605077034875040133796864147700 i": +Test "Imaginary part of: cacosh (-0x0.ffffffp0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (-0x0.ffffffp0 - 0.0 i) == 0.0 - 3.141247386605077034875040133796864147700 i": +Test "Imaginary part of: cacosh (-0x0.ffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x0.ffffffp0 - 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 - 3.141247386605077034875040133796864147700 i": +Test "Imaginary part of: cacosh (-0x0.ffffffp0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (-0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 3.141592653377875508152537040020250564229 i": +Test "Imaginary part of: cacosh (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 3.141592653377875508152537040020250564229 i": +Test "Imaginary part of: cacosh (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 3.141592643999491532482601997450598791535 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 3.141592643999491532482601997450598791535 i": +Test "Imaginary part of: cacosh (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 3.141592643999491532482601997450598791535 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 3.141592643999491532482601997450598791535 i": +Test "Imaginary part of: cacosh (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 3.141370441751352383825802745874586120521 i": +Test "Real part of: cacosh (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (-0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 3.141370441751352383825802745874586120521 i": +Test "Imaginary part of: cacosh (-0x1.000002p0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 3.141370441751352383825802745874586120521 i": +Test "Real part of: cacosh (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (-0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 3.141370441751352383825802745874586120521 i": +Test "Imaginary part of: cacosh (-0x1.000002p0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691640832196834 i": +Test "Imaginary part of: cacosh (-0x1.fp-100 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691640832196834 i": +Test "Imaginary part of: cacosh (-0x1.fp-100 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 0x1.000000000000000000000000008p0 i) == 8.813735870195430252326093249798097405561e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 0x1.000000000000000000000000008p0 i) == 8.813735870195430252326093249798097405561e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x0.ffffffp0 i) == 8.813735448726938863015878255140556727969e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.fp-129 i) == 2.846900380897727558361783801085126250967e-39 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442100 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x0.ffffffp0 i) == 8.813735448726938863015878255140556727969e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.fp-129 i) == 2.846900380897727558361783801085126250967e-39 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442100 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796328070826603447840231892468927106 i": +Test "Imaginary part of: cacosh (-0x1.fp-30 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796328070826603447840231892468927106 i": +Test "Imaginary part of: cacosh (-0x1.fp-30 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0.0 i) == 0.0 + 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639773491431 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 + 1.570796326794896619231321691639768873627 i": +Test "Real part of: cacosh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0x1p-105 i) == 2.465190328815661891911651766508706967729e-32 + 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0.0 i) == 0.0 - 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639773491431 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 - 1.570796326794896619231321691639768873627 i": +Test "Real part of: cacosh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0x1p-105 i) == 2.465190328815661891911651766508706967729e-32 - 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0.0 i) == 0.0 + 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751614359 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0x1p-112 i) == 1.925929944387235853055977942584927318538e-34 + 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0.0 i) == 0.0 - 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751614359 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0x1p-112 i) == 1.925929944387235853055977942584927318538e-34 - 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0.0 i) == 0.0 + 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796433418926613232299739606181733819 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1p-23 + 0x1.000002p0 i) == 8.813736713132400470205730751186547909968e-1 + 1.570796411088588616723617301287646121905 i": +Test "Real part of: cacosh (-0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0x1.fp-129 i) == 2.846900380897747786805634596726756660388e-39 + 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0x1p-23 i) == 1.192092895507818146886315028596704749235e-7 + 1.570796446004186170012007003008248567984 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0.0 i) == 0.0 - 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796433418926613232299739606181733819 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1p-23 - 0x1.000002p0 i) == 8.813736713132400470205730751186547909968e-1 - 1.570796411088588616723617301287646121905 i": +Test "Real part of: cacosh (-0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0x1.fp-129 i) == 2.846900380897747786805634596726756660388e-39 - 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0x1p-23 i) == 1.192092895507818146886315028596704749235e-7 - 1.570796446004186170012007003008248567984 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0.0 i) == 0.0 + 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896817834053951421591208280 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0x1p-52 i) == 2.220446049250313080847263336181677117148e-16 + 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0.0 i) == 0.0 - 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896817834053951421591208280 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0x1p-52 i) == 2.220446049250313080847263336181677117148e-16 - 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0.0 i) == 0.0 + 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619328295682000973043547 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0x1p-63 i) == 1.084202172485504434007452800869941711430e-19 + 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0.0 i) == 0.0 - 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619328295682000973043547 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0x1p-63 i) == 1.084202172485504434007452800869941711430e-19 - 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 2.466703808003786858297978415967328452322 i": +Test "Imaginary part of: cacosh (-1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 3.098101355958774410750062883737683164607 i": +Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 + 0x1.fp-100 i) == 1.236292038260260888664514866457202186027e-15 + 3.141592653589792002170605123018614219682 i": +Test "Imaginary part of: cacosh (-1.0 + 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 + 0x1p50 i) == 3.535050620855721078027883819436759661753e1 + 1.570796326794897507409741391764983781004 i": +Test "Imaginary part of: cacosh (-1.0 + 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 2.466703808003786858297978415967328452322 i": +Test "Imaginary part of: cacosh (-1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 3.098101355958774410750062883737683164607 i": +Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 - 0x1.fp-100 i) == 1.236292038260260888664514866457202186027e-15 - 3.141592653589792002170605123018614219682 i": +Test "Imaginary part of: cacosh (-1.0 - 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 - 0x1p50 i) == 3.535050620855721078027883819436759661753e1 - 1.570796326794897507409741391764983781004 i": +Test "Imaginary part of: cacosh (-1.0 - 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Real part of: cacosh (-2 - 3 i)": double: 1 float: 7 idouble: 1 ifloat: 7 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": double: 1 float: 3 idouble: 1 ifloat: 3 -Test "Real part of: cacosh (0.0 + 0x1.000000000000000000000000008p0 i) == 8.813735870195430252326093249798097405561e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x1.000000000000000000000000008p0 i) == 8.813735870195430252326093249798097405561e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.394493894017929688812643125003661339452 i": +Test "Real part of: cacosh (0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.394493894017929688812643125003661339452 i": +Test "Real part of: cacosh (0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + +0 i) == +0 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 1.047197551196597746154214461093186605110 i": +Test "Real part of: cacosh (0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 + 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.221357263937683325603909865564381489366 i": +Test "Imaginary part of: cacosh (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0.5 - 0 i) == +0 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 1.047197551196597746154214461093186605110 i": +Test "Real part of: cacosh (0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 - 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.221357263937683325603909865564381489366 i": +Test "Imaginary part of: cacosh (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0.0 i) == 0.0 + 1.490116119384765638786343542550461592240e-8 i": +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0x1.fp-1025 i) == 3.616396521699973256461764099945789620604e-301 + 1.490116119384765638786343542550461592240e-8 i": +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0.0 i) == 0.0 - 1.490116119384765638786343542550461592240e-8 i": +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0x1.fp-1025 i) == 3.616396521699973256461764099945789620604e-301 - 1.490116119384765638786343542550461592240e-8 i": +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == 1.234330349600789959989661887846005659983e-16 + 1.997188458999618357060632049675702684031e-16 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == 1.234330349600789959989661887846005659983e-16 - 1.997188458999618357060632049675702684031e-16 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i) == 0.0 + 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 + 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i) == 0.0 - 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 - 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 9.590301705980041385828904092662391018164e-9 i": +Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 9.590301705980041385828904092662391018164e-9 i": +Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 2.222118384408546368406374049167636760903e-4 i": +Test "Real part of: cacosh (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 2.222118384408546368406374049167636760903e-4 i": +Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 2.222118384408546368406374049167636760903e-4 i": +Test "Real part of: cacosh (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 2.222118384408546368406374049167636760903e-4 i": +Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.569458417435338878318763342108699202986 i": +Test "Imaginary part of: cacosh (0x1.fp-10 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.569458417435338878318763342108699202986 i": +Test "Imaginary part of: cacosh (0x1.fp-10 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691638670687364 i": +Test "Imaginary part of: cacosh (0x1.fp-100 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691638670687364 i": +Test "Imaginary part of: cacosh (0x1.fp-100 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 0x1.000000000000000000000000008p0 i) == 8.813735870195430252326093249798097405561e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 0x1.000000000000000000000000008p0 i) == 8.813735870195430252326093249798097405561e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639729392766 i": +Test "Imaginary part of: cacosh (0x1p-105 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 + 1.570796326794896619231321691639734010571 i": +Test "Real part of: cacosh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639729392766 i": +Test "Imaginary part of: cacosh (0x1p-105 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 - 1.570796326794896619231321691639734010571 i": +Test "Real part of: cacosh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1p-23 + 0x1.000002p0 i) == 8.813736713132400470205730751186547909968e-1 + 1.570796242501204621739026081991856762292 i": +Test "Real part of: cacosh (0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1p-23 - 0x1.000002p0 i) == 8.813736713132400470205730751186547909968e-1 - 1.570796242501204621739026081991856762292 i": +Test "Real part of: cacosh (0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1p-52 + 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910458761820e-1 + 1.570796326794896462222075823262236786996 i": +Test "Imaginary part of: cacosh (0x1p-52 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-52 + 0x1.0000000000001p0 i) == 8.813735870195431822418551933572982483664e-1 + 1.570796326794896462222075823262262934288 i": +Test "Imaginary part of: cacosh (0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1p-52 - 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910458761820e-1 - 1.570796326794896462222075823262236786996 i": +Test "Imaginary part of: cacosh (0x1p-52 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-52 - 0x1.0000000000001p0 i) == 8.813735870195431822418551933572982483664e-1 - 1.570796326794896462222075823262262934288 i": +Test "Imaginary part of: cacosh (0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 + 0.25 i) == 5.097911466811016354623559941115413499164e-1 + 4.890443302710802929202843732146540079124e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Real part of: cacosh (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 + 4.247867097467650115899790787875186617316e-5 i": +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0.25 i) == 5.097911466811016354623559941115413499164e-1 - 4.890443302710802929202843732146540079124e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Real part of: cacosh (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 - 4.247867097467650115899790787875186617316e-5 i": +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x1.000000000000000000000000008p0 i) == -0.0 + 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x1.000000000000000000000000008p0 i) == -0.0 - 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.25 + 1.0 i) == -1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (-0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.25 - 1.0 i) == -1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (-0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + +0 i) == -0.5235987755982988730771072305465838140329 + +0 i": +Test "Real part of: casin (-0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + 0x1.fp-1025 i) == -5.235987755982988730771072305465838140329e-1 + 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: casin (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: casin (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0.5 + 0x1p-105 i) == -5.235987755982988730771072305465838140329e-1 + 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: casin (-0.5 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-105 i) == -5.235987755982988730771072305465838140329e-1 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0.5 + 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: casin (-0.5 + 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0.5 + 0x1p-52 i) == -5.235987755982988730771072305465648369889e-1 + 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: casin (-0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-52 i) == -5.235987755982988730771072305465648369889e-1 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + 0x1p-63 i) == -5.235987755982988730771072305465838140283e-1 + 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: casin (-0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 1.0 i) == -3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 0 i) == -0.5235987755982988730771072305465838140329 - 0 i": +Test "Real part of: casin (-0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 0x1.fp-1025 i) == -5.235987755982988730771072305465838140329e-1 - 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: casin (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: casin (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0.5 - 0x1p-105 i) == -5.235987755982988730771072305465838140329e-1 - 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: casin (-0.5 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-105 i) == -5.235987755982988730771072305465838140329e-1 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0.5 - 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: casin (-0.5 - 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0.5 - 0x1p-52 i) == -5.235987755982988730771072305465648369889e-1 - 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: casin (-0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-52 i) == -5.235987755982988730771072305465648369889e-1 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 0x1p-63 i) == -5.235987755982988730771072305465838140283e-1 - 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: casin (-0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 1.0 i) == -3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i) == -1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i) == -1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 + 0.0 i) == -1.570796326794896462222075823262245502760 + 0.0 i": +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i) == -1.570796326794896462222075823262245502760 + 3.432186888910770473784103112009399360940e-293 i": +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 - 0.0 i) == -1.570796326794896462222075823262245502760 - 0.0 i": +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i) == -1.570796326794896462222075823262245502760 - 3.432186888910770473784103112009399360940e-293 i": +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -1.570796326376055842114524927965556247908 + 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -1.570796326376055842114524927965556247908 - 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffp0 + 0.0 i) == -1.570451059810180415643718442157112705601 + 0.0 i": +Test "Real part of: casin (-0x0.ffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffp0 + 0x1.fp-129 i) == -1.570451059810180415643718442157112705601 + 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: casin (-0x0.ffffffp0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffp0 + 0x1p-23 i) == -1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: casin (-0x0.ffffffp0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i) == -1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: casin (-0x0.ffffffp0 - 0.0 i) == -1.570451059810180415643718442157112705601 - 0.0 i": +Test "Real part of: casin (-0x0.ffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffp0 - 0x1.fp-129 i) == -1.570451059810180415643718442157112705601 - 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: casin (-0x0.ffffffp0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffp0 - 0x1p-23 i) == -1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: casin (-0x0.ffffffp0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i) == -1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1p-52 i) == -1.570796317204594913251280305810847349436 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1p-52 i) == -1.570796317204594913251280305810847349436 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.000002p0 + 0x1p-23 i) == -1.570574114956455764594481054234834678422 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1.000002p0 - 0x1p-23 i) == -1.570574114956455764594481054234834678422 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (-0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (-0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i) == -1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i) == -1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i) == -1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i) == -1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 0x1.000000000000000000000000008p0 i) == -3.810492908885321743133304375216570658278e-309 + 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i) == -3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i) == -2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 0x1.000000000000000000000000008p0 i) == -3.810492908885321743133304375216570658278e-309 - 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i) == -3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i) == -2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i) == -2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i) == -2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i) == -1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i) == -2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i) == -2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i) == -1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (-0x1.fp-30 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (-0x1.fp-30 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-105 + 0.5 i) == -2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == -1.743152798421049375791483240187377443526e-32 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-105 - 0.5 i) == -2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == -1.743152798421049375791483240187377443526e-32 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-112 + 0.5 i) == -1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-112 - 0.5 i) == -1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-52 + 0.5 i) == -1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-52 - 0.5 i) == -1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0.5 i) == -9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0.5 i) == -9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-1.0 + 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: casin (-1.0 + 0x1.fp-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-1.0 - 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: casin (-1.0 - 0x1.fp-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-2 - 3 i) == -0.57065278432109940071028387968566963 - 1.9833870299165354323470769028940395 i": +Test "Real part of: casin (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x1.000000000000000000000000008p0 i) == 0.0 + 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: casin (0.0 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x1.000000000000000000000000008p0 i) == 0.0 - 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: casin (0.0 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.25 + 1.0 i) == 1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.25 - 1.0 i) == 1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + +0 i) == 0.5235987755982988730771072305465838140329 + +0 i": +Test "Real part of: casin (0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + 0x1.fp-1025 i) == 5.235987755982988730771072305465838140329e-1 + 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: casin (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: casin (0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.5 + 0x1p-105 i) == 5.235987755982988730771072305465838140329e-1 + 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: casin (0.5 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-105 i) == 5.235987755982988730771072305465838140329e-1 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.5 + 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: casin (0.5 + 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.5 + 0x1p-52 i) == 5.235987755982988730771072305465648369889e-1 + 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: casin (0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-52 i) == 5.235987755982988730771072305465648369889e-1 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + 0x1p-63 i) == 5.235987755982988730771072305465838140283e-1 + 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: casin (0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 1.0 i) == 3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 0 i) == 0.5235987755982988730771072305465838140329 - 0 i": +Test "Real part of: casin (0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 0x1.fp-1025 i) == 5.235987755982988730771072305465838140329e-1 - 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: casin (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: casin (0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.5 - 0x1p-105 i) == 5.235987755982988730771072305465838140329e-1 - 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: casin (0.5 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-105 i) == 5.235987755982988730771072305465838140329e-1 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.5 - 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: casin (0.5 - 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.5 - 0x1p-52 i) == 5.235987755982988730771072305465648369889e-1 - 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: casin (0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-52 i) == 5.235987755982988730771072305465648369889e-1 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 0x1p-63 i) == 5.235987755982988730771072305465838140283e-1 - 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: casin (0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 1.0 i) == 3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i) == 1.570796326794896462222075823262245502760 + 0.0 i": +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i) == 1.570796326794896462222075823262245502760 + 3.432186888910770473784103112009399360940e-293 i": +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i) == 1.570796326794896462222075823262245502760 - 0.0 i": +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i) == 1.570796326794896462222075823262245502760 - 3.432186888910770473784103112009399360940e-293 i": +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 1.570796326376055842114524927965556247908 + 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 1.570796326376055842114524927965556247908 - 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffp0 + 0.0 i) == 1.570451059810180415643718442157112705601 + 0.0 i": +Test "Real part of: casin (0x0.ffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffp0 + 0x1.fp-129 i) == 1.570451059810180415643718442157112705601 + 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: casin (0x0.ffffffp0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffp0 + 0x1p-23 i) == 1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: casin (0x0.ffffffp0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i) == 1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: casin (0x0.ffffffp0 - 0.0 i) == 1.570451059810180415643718442157112705601 - 0.0 i": +Test "Real part of: casin (0x0.ffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffp0 - 0x1.fp-129 i) == 1.570451059810180415643718442157112705601 - 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: casin (0x0.ffffffp0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffp0 - 0x1p-23 i) == 1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: casin (0x0.ffffffp0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i) == 1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1p-52 i) == 1.570796317204594913251280305810847349436 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1p-52 i) == 1.570796317204594913251280305810847349436 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.000002p0 + 0x1p-23 i) == 1.570574114956455764594481054234834678422 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1.000002p0 - 0x1p-23 i) == 1.570574114956455764594481054234834678422 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i) == 1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i) == 1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i) == 1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i) == 1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 0x1.000000000000000000000000008p0 i) == 3.810492908885321743133304375216570658278e-309 + 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i) == 3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i) == 2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 0x1.000000000000000000000000008p0 i) == 3.810492908885321743133304375216570658278e-309 - 8.813735870195430252326093249798097405561e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i) == 3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i) == 2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i) == 2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i) == 2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i) == 1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i) == 2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i) == 2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i) == 1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (0x1.fp-30 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (0x1.fp-30 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 + 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 + 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-105 + 0.5 i) == 2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.743152798421049375791483240187377443526e-32 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-105 - 0.5 i) == 2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.743152798421049375791483240187377443526e-32 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-112 + 0.5 i) == 1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-112 - 0.5 i) == 1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-52 + 0.5 i) == 1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-52 - 0.5 i) == 1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-63 + 0.5 i) == 9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 - 0.5 i) == 9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (1.0 + 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: casin (1.0 + 0x1.fp-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (1.0 - 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: casin (1.0 - 0x1.fp-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # casinh -Test "Imaginary part of: casinh (+0 + 0.5 i) == +0 + 0.5235987755982988730771072305465838140329 i": +Test "Imaginary part of: casinh (+0 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (+0 - 0.5 i) == +0 - 0.5235987755982988730771072305465838140329 i": +Test "Imaginary part of: casinh (+0 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0 + 0.5 i) == -0 + 0.5235987755982988730771072305465838140329 i": +Test "Imaginary part of: casinh (-0 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0 - 0.5 i) == -0 - 0.5235987755982988730771072305465838140329 i": +Test "Imaginary part of: casinh (-0 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i) == -0.0 + 1.570796326794896462222075823262245502760 i": +Test "Imaginary part of: casinh (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.0 + 0x0.ffffffp0 i) == -0.0 + 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (-0.0 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i) == -0.0 - 1.570796326794896462222075823262245502760 i": +Test "Imaginary part of: casinh (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.0 - 0x0.ffffffp0 i) == -0.0 - 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (-0.0 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-0.5 + 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-0.5 - 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == -8.813735870195430252326093249797835932642e-1 + 1.743152798421049375791483240187377443526e-32 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == -8.813735870195430252326093249797835932642e-1 - 1.743152798421049375791483240187377443526e-32 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1.000000000000000000000000008p0 + 0.0 i) == -8.813735870195430252326093249798097405561e-1 + 0.0 i": +Test "Real part of: casinh (-0x1.000000000000000000000000008p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000000000000000000000000008p0 + 0x1.fp-1025 i) == -8.813735870195430252326093249798097405561e-1 + 3.810492908885321743133304375216570658278e-309 i": +Test "Real part of: casinh (-0x1.000000000000000000000000008p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000000000000000000000000008p0 - 0.0 i) == -8.813735870195430252326093249798097405561e-1 - 0.0 i": +Test "Real part of: casinh (-0x1.000000000000000000000000008p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000000000000000000000000008p0 - 0x1.fp-1025 i) == -8.813735870195430252326093249798097405561e-1 - 3.810492908885321743133304375216570658278e-309 i": +Test "Real part of: casinh (-0x1.000000000000000000000000008p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000002p0 + 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Real part of: casinh (-0x1.000002p0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.000002p0 - 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Real part of: casinh (-0x1.000002p0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.fp-10 + 1.0 i) == -4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (-0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-10 + 1.0 i) == -4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Imaginary part of: casinh (-0x1.fp-10 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-10 - 1.0 i) == -4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (-0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-10 - 1.0 i) == -4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Imaginary part of: casinh (-0x1.fp-10 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-1025 + 0.5 i) == -6.222508863508420569166420770843207333493e-309 + 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (-0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i) == -3.432186888910770473784103112009399360940e-293 + 1.570796326794896462222075823262245502760 i": +Test "Imaginary part of: casinh (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-1025 - 0.5 i) == -6.222508863508420569166420770843207333493e-309 - 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (-0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i) == -3.432186888910770473784103112009399360940e-293 - 1.570796326794896462222075823262245502760 i": +Test "Imaginary part of: casinh (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 + 0.5 i) == -3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-129 + 0.5 i) == -3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (-0x1.fp-129 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-129 + 0x0.ffffffp0 i) == -8.245504387859737323891843603996428534945e-36 + 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (-0x1.fp-129 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 - 0.5 i) == -3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-129 - 0.5 i) == -3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (-0x1.fp-129 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-129 - 0x0.ffffffp0 i) == -8.245504387859737323891843603996428534945e-36 - 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (-0x1.fp-129 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-105 + 0.5 i) == -2.846556599890768890940941645338546615370e-32 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-105 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1p-105 + 0.5 i) == -2.846556599890768890940941645338546615370e-32 + 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (-0x1p-105 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-105 - 0.5 i) == -2.846556599890768890940941645338546615370e-32 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-105 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1p-105 - 0.5 i) == -2.846556599890768890940941645338546615370e-32 - 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (-0x1p-105 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-112 + 0.5 i) == -2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-112 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1p-112 + 0.5 i) == -2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (-0x1p-112 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-112 - 0.5 i) == -2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-112 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1p-112 - 0.5 i) == -2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (-0x1p-112 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0.5 i) == -1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casinh (-0x1p-23 + 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Imaginary part of: casinh (-0x1p-23 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0x1.000002p0 i) == -5.364668491573609633134147164031476452679e-4 + 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (-0x1p-23 + 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-0x1p-23 - 0.5 i) == -1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casinh (-0x1p-23 - 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Imaginary part of: casinh (-0x1p-23 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0x1.000002p0 i) == -5.364668491573609633134147164031476452679e-4 - 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (-0x1p-23 - 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-0x1p-52 + 0.5 i) == -2.563950248511418570403591756798643804971e-16 + 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (-0x1p-52 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-52 + 0.5 i) == -2.563950248511418570403591756798643804971e-16 + 5.235987755982988730771072305465648369889e-1 i": +Test "Imaginary part of: casinh (-0x1p-52 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0x1.0000000000001p0 i) == -2.315303644582684770975188768022139415020e-8 + 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (-0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0.5 i) == -2.563950248511418570403591756798643804971e-16 - 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (-0x1p-52 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-52 - 0.5 i) == -2.563950248511418570403591756798643804971e-16 - 5.235987755982988730771072305465648369889e-1 i": +Test "Imaginary part of: casinh (-0x1p-52 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0x1.0000000000001p0 i) == -2.315303644582684770975188768022139415020e-8 - 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (-0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-63 + 0.5 i) == -1.251928832280966098829878787499365228659e-19 + 5.235987755982988730771072305465838140283e-1 i": +Test "Imaginary part of: casinh (-0x1p-63 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -2.588578361325995866221775673638805081337e-10 + 1.570796326376055842114524927965556247908 i": +Test "Imaginary part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-63 - 0.5 i) == -1.251928832280966098829878787499365228659e-19 - 5.235987755982988730771072305465838140283e-1 i": +Test "Imaginary part of: casinh (-0x1p-63 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -2.588578361325995866221775673638805081337e-10 - 1.570796326376055842114524927965556247908 i": +Test "Imaginary part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0.25 i) == -8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (-1.0 + 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0.5 i) == -9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0.25 i) == -8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (-1.0 - 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0.5 i) == -9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i) == 0.0 + 1.570796326794896462222075823262245502760 i": +Test "Imaginary part of: casinh (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.0 + 0x0.ffffffp0 i) == 0.0 + 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (0.0 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i) == 0.0 - 1.570796326794896462222075823262245502760 i": +Test "Imaginary part of: casinh (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.0 - 0x0.ffffffp0 i) == 0.0 - 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (0.0 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == 8.813735870195430252326093249797835932642e-1 + 1.743152798421049375791483240187377443526e-32 i": +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == 8.813735870195430252326093249797835932642e-1 - 1.743152798421049375791483240187377443526e-32 i": +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.000000000000000000000000008p0 + 0.0 i) == 8.813735870195430252326093249798097405561e-1 + 0.0 i": +Test "Real part of: casinh (0x1.000000000000000000000000008p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000000000000000000000000008p0 + 0x1.fp-1025 i) == 8.813735870195430252326093249798097405561e-1 + 3.810492908885321743133304375216570658278e-309 i": +Test "Real part of: casinh (0x1.000000000000000000000000008p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000000000000000000000000008p0 - 0.0 i) == 8.813735870195430252326093249798097405561e-1 - 0.0 i": +Test "Real part of: casinh (0x1.000000000000000000000000008p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000000000000000000000000008p0 - 0x1.fp-1025 i) == 8.813735870195430252326093249798097405561e-1 - 3.810492908885321743133304375216570658278e-309 i": +Test "Real part of: casinh (0x1.000000000000000000000000008p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000002p0 + 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Real part of: casinh (0x1.000002p0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1.000002p0 - 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Real part of: casinh (0x1.000002p0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1.fp-10 + 1.0 i) == 4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-10 + 1.0 i) == 4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Imaginary part of: casinh (0x1.fp-10 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-10 - 1.0 i) == 4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-10 - 1.0 i) == 4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Imaginary part of: casinh (0x1.fp-10 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-1025 + 0.5 i) == 6.222508863508420569166420770843207333493e-309 + 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i) == 3.432186888910770473784103112009399360940e-293 + 1.570796326794896462222075823262245502760 i": +Test "Imaginary part of: casinh (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-1025 - 0.5 i) == 6.222508863508420569166420770843207333493e-309 - 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i) == 3.432186888910770473784103112009399360940e-293 - 1.570796326794896462222075823262245502760 i": +Test "Imaginary part of: casinh (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 + 0.5 i) == 3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1.fp-129 + 0.5 i) == 3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (0x1.fp-129 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-129 + 0x0.ffffffp0 i) == 8.245504387859737323891843603996428534945e-36 + 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (0x1.fp-129 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 - 0.5 i) == 3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1.fp-129 - 0.5 i) == 3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (0x1.fp-129 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-129 - 0x0.ffffffp0 i) == 8.245504387859737323891843603996428534945e-36 - 1.570451059810180415643718442157112705601 i": +Test "Imaginary part of: casinh (0x1.fp-129 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-105 + 0.5 i) == 2.846556599890768890940941645338546615370e-32 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-105 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1p-105 + 0.5 i) == 2.846556599890768890940941645338546615370e-32 + 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (0x1p-105 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-105 - 0.5 i) == 2.846556599890768890940941645338546615370e-32 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-105 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1p-105 - 0.5 i) == 2.846556599890768890940941645338546615370e-32 - 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (0x1p-105 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-112 + 0.5 i) == 2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-112 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1p-112 + 0.5 i) == 2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (0x1p-112 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-112 - 0.5 i) == 2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-112 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1p-112 - 0.5 i) == 2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (0x1p-112 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 + 0.5 i) == 1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casinh (0x1p-23 + 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Imaginary part of: casinh (0x1p-23 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 + 0x1.000002p0 i) == 5.364668491573609633134147164031476452679e-4 + 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (0x1p-23 + 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0x1p-23 - 0.5 i) == 1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casinh (0x1p-23 - 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Imaginary part of: casinh (0x1p-23 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0x1.000002p0 i) == 5.364668491573609633134147164031476452679e-4 - 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (0x1p-23 - 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0x1p-52 + 0.5 i) == 2.563950248511418570403591756798643804971e-16 + 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (0x1p-52 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-52 + 0.5 i) == 2.563950248511418570403591756798643804971e-16 + 5.235987755982988730771072305465648369889e-1 i": +Test "Imaginary part of: casinh (0x1p-52 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-52 + 0x1.0000000000001p0 i) == 2.315303644582684770975188768022139415020e-8 + 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 - 0.5 i) == 2.563950248511418570403591756798643804971e-16 - 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (0x1p-52 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-52 - 0.5 i) == 2.563950248511418570403591756798643804971e-16 - 5.235987755982988730771072305465648369889e-1 i": +Test "Imaginary part of: casinh (0x1p-52 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-52 - 0x1.0000000000001p0 i) == 2.315303644582684770975188768022139415020e-8 - 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-63 + 0.5 i) == 1.251928832280966098829878787499365228659e-19 + 5.235987755982988730771072305465838140283e-1 i": +Test "Imaginary part of: casinh (0x1p-63 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 2.588578361325995866221775673638805081337e-10 + 1.570796326376055842114524927965556247908 i": +Test "Imaginary part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-63 - 0.5 i) == 1.251928832280966098829878787499365228659e-19 - 5.235987755982988730771072305465838140283e-1 i": +Test "Imaginary part of: casinh (0x1p-63 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 2.588578361325995866221775673638805081337e-10 - 1.570796326376055842114524927965556247908 i": +Test "Imaginary part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0.25 i) == 8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (1.0 + 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0.5 i) == 9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0.25 i) == 8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (1.0 - 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0.5 i) == 9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 # catan -Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i) == -7.853981633974482679822974223765039144191e-1 + 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 - 0x1p-27 i) == -7.853981633974482679822974223765039144191e-1 - 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 - 0x1p-27 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i) == -7.853981373204155542484315721351697277336e-1 + 6.103515973639646453881721999956617260502e-5 i": +Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000000000000000000000000008p0 + 0x1p-54 i) == -7.853981633974483096156608458198888173729e-1 + 2.775557561562891351059079170226980932999e-17 i": +Test "Real part of: catan (-0x1.000000000000000000000000008p0 + 0x1p-54 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1.000000000000000000000000008p0 - 0x1p-54 i) == -7.853981633974483096156608458198888173729e-1 - 2.775557561562891351059079170226980932999e-17 i": +Test "Real part of: catan (-0x1.000000000000000000000000008p0 - 0x1p-54 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.0000000000001p0 - 0x1p-27 i) == -7.853981633974484345157511161499711112683e-1 - 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (-0x1.0000000000001p0 - 0x1p-27 i)": double: 1 idouble: 1 -Test "Real part of: catan (-0x1.000002p0 + 0x1p-126 i) == -7.853982230020895322927482174768220815493e-1 + 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (-0x1.000002p0 + 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000002p0 + 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 + 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000002p0 - 0x1p-126 i) == -7.853982230020895322927482174768220815493e-1 - 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (-0x1.000002p0 - 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000002p0 - 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i) == -1.570796326794896619231321691639751442099 + 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i) == -1.570796326794896619231321691639751442099 - 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i) == -1.570796326794896619231321691639751442097 + 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i) == -1.570796326794896619231321691639751442097 - 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i) == -7.853981633974483096156608458198757210493e-1 + 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i) == -7.853981633974483096156608458198757210493e-1 - 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: catan (-0x1p-13 + 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 + 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (-0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 + 1.0 i) == -7.854286809755354140031716771044626356262e-1 + 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (-0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 - 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-13 - 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Imaginary part of: catan (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 - 1.0 i) == -7.854286809755354140031716771044626356262e-1 - 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (-0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-27 + 1.0 i) == -7.853981652600934588466178684534110069553e-1 + 9.704060527839234335310696652368086117807 i": +Test "Real part of: catan (-0x1p-27 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-27 - 1.0 i) == -7.853981652600934588466178684534110069553e-1 - 9.704060527839234335310696652368086117807 i": +Test "Real part of: catan (-0x1p-27 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-33 + 1.0 i) == -7.853981634265521400723945494331241018449e-1 + 1.178350206951907026009379309773625595762e1 i": +Test "Real part of: catan (-0x1p-33 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-33 - 1.0 i) == -7.853981634265521400723945494331241018449e-1 - 1.178350206951907026009379309773625595762e1 i": +Test "Real part of: catan (-0x1p-33 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-54 + 1.0 i) == -7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Real part of: catan (-0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-54 + 1.0 i) == -7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (-0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-54 - 1.0 i) == -7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Real part of: catan (-0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-54 - 1.0 i) == -7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (-0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-57 + 1.0 i) == -7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Real part of: catan (-0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-57 + 1.0 i) == -7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (-0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-57 - 1.0 i) == -7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Real part of: catan (-0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-57 - 1.0 i) == -7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (-0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 + 0x1p-13 i) == -7.853981671227386080775748393881580082970e-1 + 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (-1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 + 0x1p-27 i) == -7.853981633974483234934486536343324763447e-1 + 3.725290298461914028034141143623846306386e-9 i": +Test "Real part of: catan (-1.0 + 0x1p-27 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 + 0x1p-33 i) == -7.853981633974483096190489776088929224056e-1 + 5.820766091346740722643102318246316469910e-11 i": +Test "Real part of: catan (-1.0 + 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 + 0x1p-54 i) == -7.853981633974483096156608458198764914213e-1 + 2.775557561562891351059079170227049355775e-17 i": +Test "Real part of: catan (-1.0 + 0x1p-54 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (-1.0 + 0x1p-57 i) == -7.853981633974483096156608458198757330864e-1 + 3.469446951953614188823848962783813448721e-18 i": +Test "Real part of: catan (-1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 - 0x1p-13 i) == -7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (-1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 - 0x1p-27 i) == -7.853981633974483234934486536343324763447e-1 - 3.725290298461914028034141143623846306386e-9 i": +Test "Real part of: catan (-1.0 - 0x1p-27 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 - 0x1p-33 i) == -7.853981633974483096190489776088929224056e-1 - 5.820766091346740722643102318246316469910e-11 i": +Test "Real part of: catan (-1.0 - 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 - 0x1p-54 i) == -7.853981633974483096156608458198764914213e-1 - 2.775557561562891351059079170227049355775e-17 i": +Test "Real part of: catan (-1.0 - 0x1p-54 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (-1.0 - 0x1p-57 i) == -7.853981633974483096156608458198757330864e-1 - 3.469446951953614188823848962783813448721e-18 i": +Test "Real part of: catan (-1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Real part of: catan (-2 - 3 i)": float: 3 ifloat: 3 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: catan (0.75 + 1.25 i) == 1.10714871779409050301706546017853704 + 0.549306144334054845697622618461262852 i": +Test "Real part of: catan (0.75 + 1.25 i)": float: 4 ifloat: 4 -Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i) == 7.853981633974482679822974223765039144191e-1 + 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x0.fffffffffffff8p0 - 0x1p-27 i) == 7.853981633974482679822974223765039144191e-1 - 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (0x0.fffffffffffff8p0 - 0x1p-27 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i) == 7.853981373204155542484315721351697277336e-1 + 6.103515973639646453881721999956617260502e-5 i": +Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: catan (0x1.000000000000000000000000008p0 + 0x1p-54 i) == 7.853981633974483096156608458198888173729e-1 + 2.775557561562891351059079170226980932999e-17 i": +Test "Real part of: catan (0x1.000000000000000000000000008p0 + 0x1p-54 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1.000000000000000000000000008p0 - 0x1p-54 i) == 7.853981633974483096156608458198888173729e-1 - 2.775557561562891351059079170226980932999e-17 i": +Test "Real part of: catan (0x1.000000000000000000000000008p0 - 0x1p-54 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.0000000000001p0 - 0x1p-27 i) == 7.853981633974484345157511161499711112683e-1 - 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (0x1.0000000000001p0 - 0x1p-27 i)": double: 1 idouble: 1 -Test "Real part of: catan (0x1.000002p0 + 0x1p-126 i) == 7.853982230020895322927482174768220815493e-1 + 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (0x1.000002p0 + 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1.000002p0 + 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 + 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1.000002p0 - 0x1p-126 i) == 7.853982230020895322927482174768220815493e-1 - 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (0x1.000002p0 - 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1.000002p0 - 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i) == 1.570796326794896619231321691639751442099 + 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i) == 1.570796326794896619231321691639751442099 - 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i) == 1.570796326794896619231321691639751442097 + 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i) == 1.570796326794896619231321691639751442097 - 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-1020 + 1.0 i) == 7.853981633974483096156608458198757210493e-1 + 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (0x1p-1020 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1p-1020 - 1.0 i) == 7.853981633974483096156608458198757210493e-1 - 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (0x1p-1020 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: catan (0x1p-13 + 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 + 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 + 1.0 i) == 7.854286809755354140031716771044626356262e-1 + 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 - 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-13 - 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Imaginary part of: catan (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 - 1.0 i) == 7.854286809755354140031716771044626356262e-1 - 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-27 + 1.0 i) == 7.853981652600934588466178684534110069553e-1 + 9.704060527839234335310696652368086117807 i": +Test "Real part of: catan (0x1p-27 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-27 - 1.0 i) == 7.853981652600934588466178684534110069553e-1 - 9.704060527839234335310696652368086117807 i": +Test "Real part of: catan (0x1p-27 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-33 + 1.0 i) == 7.853981634265521400723945494331241018449e-1 + 1.178350206951907026009379309773625595762e1 i": +Test "Real part of: catan (0x1p-33 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-33 - 1.0 i) == 7.853981634265521400723945494331241018449e-1 - 1.178350206951907026009379309773625595762e1 i": +Test "Real part of: catan (0x1p-33 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-54 + 1.0 i) == 7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Real part of: catan (0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-54 + 1.0 i) == 7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-54 - 1.0 i) == 7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Real part of: catan (0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-54 - 1.0 i) == 7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-57 + 1.0 i) == 7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Real part of: catan (0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-57 + 1.0 i) == 7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-57 - 1.0 i) == 7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Real part of: catan (0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-57 - 1.0 i) == 7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 + 0x1p-13 i) == 7.853981671227386080775748393881580082970e-1 + 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 + 0x1p-27 i) == 7.853981633974483234934486536343324763447e-1 + 3.725290298461914028034141143623846306386e-9 i": +Test "Real part of: catan (1.0 + 0x1p-27 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 + 0x1p-33 i) == 7.853981633974483096190489776088929224056e-1 + 5.820766091346740722643102318246316469910e-11 i": +Test "Real part of: catan (1.0 + 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 + 0x1p-54 i) == 7.853981633974483096156608458198764914213e-1 + 2.775557561562891351059079170227049355775e-17 i": +Test "Real part of: catan (1.0 + 0x1p-54 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (1.0 + 0x1p-57 i) == 7.853981633974483096156608458198757330864e-1 + 3.469446951953614188823848962783813448721e-18 i": +Test "Real part of: catan (1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 - 0x1p-13 i) == 7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 - 0x1p-27 i) == 7.853981633974483234934486536343324763447e-1 - 3.725290298461914028034141143623846306386e-9 i": +Test "Real part of: catan (1.0 - 0x1p-27 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 - 0x1p-33 i) == 7.853981633974483096190489776088929224056e-1 - 5.820766091346740722643102318246316469910e-11 i": +Test "Real part of: catan (1.0 - 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 - 0x1p-54 i) == 7.853981633974483096156608458198764914213e-1 - 2.775557561562891351059079170227049355775e-17 i": +Test "Real part of: catan (1.0 - 0x1p-54 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (1.0 - 0x1p-57 i) == 7.853981633974483096156608458198757330864e-1 - 3.469446951953614188823848962783813448721e-18 i": +Test "Real part of: catan (1.0 - 0x1p-57 i)": float: 1 ifloat: 1 # catanh -Test "Real part of: catanh (-0x1.000002p0 + 0x1p-13 i) == -4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Real part of: catanh (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1.000002p0 + 0x1p-13 i) == -4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1.000002p0 - 0x1p-13 i) == -4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Real part of: catanh (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1.000002p0 - 0x1p-13 i) == -4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i) == -2.871063043235098558826106732041811695767e-309 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i) == -2.871063043235098558826106732041811695767e-309 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i) == -1.516766904286822590927401983512575068153e-39 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i) == -1.516766904286822590927401983512575068153e-39 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-126 + 0x1.000002p0 i) == -5.877471053462247139383742414506671233336e-39 + 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (-0x1p-126 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-126 - 0x1.000002p0 i) == -5.877471053462247139383742414506671233336e-39 - 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (-0x1p-126 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-13 + 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-13 + 1.0 i) == -6.103515609841754902688560615027452023669e-5 + 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-13 - 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-13 - 1.0 i) == -6.103515609841754902688560615027452023669e-5 - 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-27 + 0x0.fffffffffffff8p0 i) == -3.725290298461914441624447420137706700965e-9 + 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (-0x1p-27 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-27 + 0x1.0000000000001p0 i) == -3.725290298461913200853528590596263270474e-9 + 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (-0x1p-27 + 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-27 + 1.0 i) == -3.725290298461914028034141143623846306386e-9 + 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (-0x1p-27 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-27 - 0x0.fffffffffffff8p0 i) == -3.725290298461914441624447420137706700965e-9 - 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (-0x1p-27 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-27 - 0x1.0000000000001p0 i) == -3.725290298461913200853528590596263270474e-9 - 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (-0x1p-27 - 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-27 - 1.0 i) == -3.725290298461914028034141143623846306386e-9 - 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (-0x1p-27 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-33 + 1.0 i) == -5.820766091346740722643102318246316469910e-11 + 7.853981633974483096190489776088929224056e-1 i": +Test "Imaginary part of: catanh (-0x1p-33 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-33 - 1.0 i) == -5.820766091346740722643102318246316469910e-11 - 7.853981633974483096190489776088929224056e-1 i": +Test "Imaginary part of: catanh (-0x1p-33 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-54 + 0x1.000000000000000000000000008p0 i) == -2.775557561562891351059079170226980932999e-17 + 7.853981633974483096156608458198888173729e-1 i": +Test "Imaginary part of: catanh (-0x1p-54 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-54 + 1.0 i) == -2.775557561562891351059079170227049355775e-17 + 7.853981633974483096156608458198764914213e-1 i": +Test "Imaginary part of: catanh (-0x1p-54 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-54 - 0x1.000000000000000000000000008p0 i) == -2.775557561562891351059079170226980932999e-17 - 7.853981633974483096156608458198888173729e-1 i": +Test "Imaginary part of: catanh (-0x1p-54 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-54 - 1.0 i) == -2.775557561562891351059079170227049355775e-17 - 7.853981633974483096156608458198764914213e-1 i": +Test "Imaginary part of: catanh (-0x1p-54 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-57 + 1.0 i) == -3.469446951953614188823848962783813448721e-18 + 7.853981633974483096156608458198757330864e-1 i": +Test "Imaginary part of: catanh (-0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-57 - 1.0 i) == -3.469446951953614188823848962783813448721e-18 - 7.853981633974483096156608458198757330864e-1 i": +Test "Imaginary part of: catanh (-0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 + 0x1p-1020 i) == -3.538516356758520804574969980043991380025e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-13 i) == -4.852030264850939738801379894163661227127 + 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-27 i) == -9.704060527839234335310696652368086117807 + 7.853981652600934588466178684534110069553e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-27 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-33 i) == -1.178350206951907026009379309773625595762e1 + 7.853981634265521400723945494331241018449e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 + 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 + 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-1020 i) == -3.538516356758520804574969980043991380025e2 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-13 i) == -4.852030264850939738801379894163661227127 - 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-27 i) == -9.704060527839234335310696652368086117807 - 7.853981652600934588466178684534110069553e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-27 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-33 i) == -1.178350206951907026009379309773625595762e1 - 7.853981634265521400723945494331241018449e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Imaginary part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Imaginary part of: catanh (-2 - 3 i)": float: 4 ifloat: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Imaginary part of: catanh (0.75 + 1.25 i)": float: 6 ifloat: 6 -Test "Imaginary part of: catanh (0x1.000002p0 + 0x1p-13 i) == 4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1.000002p0 - 0x1p-13 i) == 4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i) == 2.871063043235098558826106732041811695767e-309 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i) == 2.871063043235098558826106732041811695767e-309 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i) == 1.516766904286822590927401983512575068153e-39 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i) == 1.516766904286822590927401983512575068153e-39 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-126 + 0x1.000002p0 i) == 5.877471053462247139383742414506671233336e-39 + 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (0x1p-126 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-126 - 0x1.000002p0 i) == 5.877471053462247139383742414506671233336e-39 - 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (0x1p-126 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i) == 6.103515973639646453881721999956617260502e-5 + 7.853981373204155542484315721351697277336e-1 i": +Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 + 0x1.000002p0 i) == 6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 + 1.0 i) == 6.103515609841754902688560615027452023669e-5 + 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i) == 6.103515973639646453881721999956617260502e-5 - 7.853981373204155542484315721351697277336e-1 i": +Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 - 0x1.000002p0 i) == 6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 - 1.0 i) == 6.103515609841754902688560615027452023669e-5 - 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i) == 3.725290298461914441624447420137706700965e-9 + 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (0x1p-27 + 1.0 i) == 3.725290298461914028034141143623846306386e-9 + 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (0x1p-27 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i) == 3.725290298461914441624447420137706700965e-9 - 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (0x1p-27 - 1.0 i) == 3.725290298461914028034141143623846306386e-9 - 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (0x1p-27 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-33 + 1.0 i) == 5.820766091346740722643102318246316469910e-11 + 7.853981633974483096190489776088929224056e-1 i": +Test "Imaginary part of: catanh (0x1p-33 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-33 - 1.0 i) == 5.820766091346740722643102318246316469910e-11 - 7.853981633974483096190489776088929224056e-1 i": +Test "Imaginary part of: catanh (0x1p-33 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-54 + 0x1.000000000000000000000000008p0 i) == 2.775557561562891351059079170226980932999e-17 + 7.853981633974483096156608458198888173729e-1 i": +Test "Imaginary part of: catanh (0x1p-54 + 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-54 + 1.0 i) == 2.775557561562891351059079170227049355775e-17 + 7.853981633974483096156608458198764914213e-1 i": +Test "Imaginary part of: catanh (0x1p-54 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-54 - 0x1.000000000000000000000000008p0 i) == 2.775557561562891351059079170226980932999e-17 - 7.853981633974483096156608458198888173729e-1 i": +Test "Imaginary part of: catanh (0x1p-54 - 0x1.000000000000000000000000008p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-54 - 1.0 i) == 2.775557561562891351059079170227049355775e-17 - 7.853981633974483096156608458198764914213e-1 i": +Test "Imaginary part of: catanh (0x1p-54 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-57 + 1.0 i) == 3.469446951953614188823848962783813448721e-18 + 7.853981633974483096156608458198757330864e-1 i": +Test "Imaginary part of: catanh (0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-57 - 1.0 i) == 3.469446951953614188823848962783813448721e-18 - 7.853981633974483096156608458198757330864e-1 i": +Test "Imaginary part of: catanh (0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 + 0x1p-1020 i) == 3.538516356758520804574969980043991380025e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-13 i) == 4.852030264850939738801379894163661227127 + 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-27 i) == 9.704060527839234335310696652368086117807 + 7.853981652600934588466178684534110069553e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-27 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-33 i) == 1.178350206951907026009379309773625595762e1 + 7.853981634265521400723945494331241018449e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 + 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 + 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-1020 i) == 3.538516356758520804574969980043991380025e2 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-13 i) == 4.852030264850939738801379894163661227127 - 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-27 i) == 9.704060527839234335310696652368086117807 - 7.853981652600934588466178684534110069553e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-27 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-33 i) == 1.178350206951907026009379309773625595762e1 - 7.853981634265521400723945494331241018449e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-57 i)": float: 1 ifloat: 1 # cbrt -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cexp -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Imaginary part of: cexp (500 + 0x1p1023 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-2 - 3 i) == 1.2824746787307683680267437207826593 - 2.1587989303424641704769327722648368 i": +Test "Imaginary part of: clog (-2 - 3 i)": float: 3 ifloat: 3 ildouble: 1 ldouble: 1 -Test "Real part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Real part of: clog (0.75 + 1.25 i)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Imaginary part of: clog (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 709.8942846690411016323109979483151967689 + 0.4636476090008061606231772164674799632783 i": +Test "Imaginary part of: clog (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x11682p-23 + 0x7ffed1p-23 i) == 1.1723955140027907954461000991619077811832e-12 + 1.5622968405332756349813737986164832897108 i": +Test "Imaginary part of: clog (0x11682p-23 + 0x7ffed1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x155f8afc4c48685bf63610p-85 + 0x17d0cf2652cdbeb1294e19p-85 i) == -4.7775669192897997174762089350332738583822e-50 + 0.8393953487996880419413728440067635213372 i": +Test "Imaginary part of: clog (0x155f8afc4c48685bf63610p-85 + 0x17d0cf2652cdbeb1294e19p-85 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i) == 1.0168910106364605304135563536838075568606e-30 + 0.8208373755522359859870890246475340086663 i": +Test "Imaginary part of: clog (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x187190c1a334497bdbde5a95f48p-106 + 0x3b25f08062d0a095c4cfbbc338dp-106 i) == -1.7471844652198029695350765775994001163767e-63 + 1.1789110097072986038243729592318526094314 i": +Test "Imaginary part of: clog (0x187190c1a334497bdbde5a95f48p-106 + 0x3b25f08062d0a095c4cfbbc338dp-106 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog (0x4d4ep-15 + 0x6605p-15 i) == -1.6298145321400412054744424587143483169412e-08 + 0.9223574537155056772124552172295398141249 i": +Test "Imaginary part of: clog (0x4d4ep-15 + 0x6605p-15 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i) == 6.4064442119814669184296141278612389400075e-37 + 0.9193591364645830864185131402313014890145 i": +Test "Imaginary part of: clog (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i) == 4.3299788920664682288477984749202524623248e-63 + 1.4746938237585656250866370987773473745867 i": +Test "Imaginary part of: clog (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xa1f2c1p-24 + 0xc643aep-24 i) == -1.0480505352462576151523512837107080269981e-13 + 0.8858771987699967480545613322309315260313 i": +Test "Imaginary part of: clog (0xa1f2c1p-24 + 0xc643aep-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xa4722f19346cp-51 + 0x7f9631c5e7f07p-51 i) == -6.2122796286154679676173624516405339768606e-30 + 1.4904138780720095276446375492434049214172 i": +Test "Imaginary part of: clog (0xa4722f19346cp-51 + 0x7f9631c5e7f07p-51 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xf2p-10 + 0x3e3p-10 i) == 6.1988446308070710970664736815277450078106e-06 + 1.3322126499153926210226335249558203898460 i": +Test "Imaginary part of: clog (0xf2p-10 + 0x3e3p-10 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Real part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 float: 5 idouble: 1 ifloat: 5 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Real part of: clog10 (0.75 + 1.25 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 308.4052305577487344482591243175787477115 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 308.3031705664207720674749211936626341569 + 0.2013595981366865903254995612594728746470 i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Imaginary part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x155f8afc4c48685bf63610p-85 + 0x17d0cf2652cdbeb1294e19p-85 i) == -2.0748709499710785084693619097712106753591e-50 + 0.3645447681189598740620098186365764884771 i": +Test "Imaginary part of: clog10 (0x155f8afc4c48685bf63610p-85 + 0x17d0cf2652cdbeb1294e19p-85 i)": ildouble: 2 ldouble: 2 -Test "Real part of: clog10 (0x15d8ab6ed05ca514086ac3a1e84p-105 + 0x1761e480aa094c0b10b34b09ce9p-105 i) == 4.3548095442952115860848857519953610343042e-63 + 0.3558376234889641500775150477035448866763 i": +Test "Real part of: clog10 (0x15d8ab6ed05ca514086ac3a1e84p-105 + 0x1761e480aa094c0b10b34b09ce9p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i) == -322.8546703496198318667349645920187712089 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i) == -5.1816837072162316773907242302011632570857e-37 + 0.5386167838952956925896424154370364458140 i": +Test "Imaginary part of: clog10 (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Imaginary part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x81b7efa81fc35ad1p-65 + 0x1ef4b835f1c79d812p-65 i) == -4.3074341162203896332989394770760901408798e-39 + 0.5709443672155660428417571212549720987784 i": +Test "Imaginary part of: clog10 (0x81b7efa81fc35ad1p-65 + 0x1ef4b835f1c79d812p-65 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 @@ -5098,227 +5098,227 @@ ildouble: 1 ldouble: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (16.0) == -0.9576594803233846418996372326511034717803": +Test "cos (16.0)": ildouble: 2 ldouble: 2 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "cos (pi/2) == 0": +Test "cos (pi/2)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_downward (10)": ildouble: 1 ldouble: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 -Test "cos_downward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_downward (6)": ildouble: 1 ldouble: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "cos_downward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_downward (9)": ildouble: 1 ldouble: 1 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cos_towardzero -Test "cos_towardzero (1) == 0.5403023058681397174009366074429766037323": +Test "cos_towardzero (1)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (10) == -0.8390715290764524522588639478240648345199": +Test "cos_towardzero (10)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 -Test "cos_towardzero (4) == -0.6536436208636119146391681830977503814241": +Test "cos_towardzero (4)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cos_upward -Test "cos_upward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_upward (1)": ildouble: 2 ldouble: 2 -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_upward (4)": ildouble: 1 ldouble: 1 -Test "cos_upward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_upward (5)": ildouble: 1 ldouble: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_tonearest -Test "cosh_tonearest (24) == 13244561064.92173614708845674912733665919": +Test "cosh_tonearest (24)": ildouble: 1 ldouble: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_upward -Test "cosh_upward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_upward (22)": ildouble: 2 ldouble: 2 -Test "cosh_upward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_upward (23)": ildouble: 2 ldouble: 2 -Test "cosh_upward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_upward (24)": ildouble: 2 ldouble: 2 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 4 idouble: 2 ifloat: 4 ildouble: 4 ldouble: 4 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 5 idouble: 1 ifloat: 5 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 @@ -5327,273 +5327,273 @@ ildouble: 2 ldouble: 2 # csin -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # csinh -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # csqrt -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Imaginary part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Imaginary part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0 - 1 i) == M_SQRT_2_2 - M_SQRT_2_2 i": +Test "Real part of: csqrt (0 - 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0 - 1 i) == M_SQRT_2_2 - M_SQRT_2_2 i": +Test "Imaginary part of: csqrt (0 - 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1p-1073 + 0x1p-1073 i) == 3.453664695497464982856905711457966660085e-162 + 1.430554756764195530630723976279903095110e-162 i": +Test "Real part of: csqrt (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1p-1073 + 0x1p-1073 i) == 3.453664695497464982856905711457966660085e-162 + 1.430554756764195530630723976279903095110e-162 i": +Test "Imaginary part of: csqrt (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1p-1074 + 0x1p-1074 i) == 2.442109726130830256743814843868934877597e-162 + 1.011554969366634726113090867589031782487e-162 i": +Test "Imaginary part of: csqrt (0x1p-1074 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1p-147 + 0x1p-147 i) == 8.225610928685557596194006925540350401606e-23 + 3.407159605465907500737319471202779419102e-23 i": +Test "Real part of: csqrt (0x1p-147 + 0x1p-147 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1p-147 + 0x1p-147 i) == 8.225610928685557596194006925540350401606e-23 + 3.407159605465907500737319471202779419102e-23 i": +Test "Imaginary part of: csqrt (0x1p-147 + 0x1p-147 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (0x1p-149 + 0x1p-149 i) == 4.112805464342778798097003462770175200803e-23 + 1.703579802732953750368659735601389709551e-23 i": +Test "Real part of: csqrt (0x1p-149 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: csqrt (0x1p-149 + 0x1p-149 i) == 4.112805464342778798097003462770175200803e-23 + 1.703579802732953750368659735601389709551e-23 i": +Test "Imaginary part of: csqrt (0x1p-149 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 ifloat: 2 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Real part of: ctan (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Imaginary part of: ctan (0x1p1023 + 1 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Real part of: ctan (0x1p127 + 1 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 47 i) == 2.729321264492904590777293425576722354636e-41 + 1.0 i": +Test "Real part of: ctan (1 + 47 i)": ildouble: 1 ldouble: 1 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 10 ldouble: 10 # ctan_tonearest -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 13 ldouble: 13 -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 10 ldouble: 10 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 6 ldouble: 6 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 10 ldouble: 10 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 @@ -5602,71 +5602,71 @@ ildouble: 1 ldouble: 1 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 2 idouble: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Real part of: ctanh (1 + 0x1p1023 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Imaginary part of: ctanh (1 + 0x1p127 i)": double: 1 float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (47 + 1 i) == 1.0 + 2.729321264492904590777293425576722354636e-41 i": +Test "Imaginary part of: ctanh (47 + 1 i)": ildouble: 1 ldouble: 1 # ctanh_downward -Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 10 ldouble: 10 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 @@ -5675,52 +5675,52 @@ ildouble: 4 ldouble: 4 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 13 ldouble: 13 -Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 4 ldouble: 4 -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 10 ldouble: 10 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # ctanh_upward -Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 10 ldouble: 10 -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 6 ldouble: 6 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 @@ -5729,208 +5729,220 @@ ildouble: 3 ldouble: 3 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0.75) == 0.288844366346484868401062165408589223": +Test "erfc (0.75)": float: 1 ifloat: 1 -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 -Test "erfc (0x1.ffff56789abcdef0123456789a8p+2) == 1.123161416304655390092138725253789378459e-29": +Test "erfc (0x1.ffff56789abcdef0123456789a8p+2)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp -Test "exp (0.75) == 2.11700001661267466854536981983709561": +Test "exp (0.75)": ildouble: 1 ldouble: 1 -Test "exp (50.0) == 5184705528587072464087.45332293348538": +Test "exp (50.0)": ildouble: 1 ldouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 -Test "exp10 (0.75) == 5.62341325190349080394951039776481231": +Test "exp10 (0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 # exp2 -Test "exp2 (10) == 1024": +Test "exp2 (10)": ildouble: 2 ldouble: 2 # exp_downward -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_towardzero -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # expm1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 +# gamma +Test "gamma (0.7)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "gamma (1.2)": +double: 1 +float: 2 +idouble: 1 +ifloat: 2 + # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "hypot (0.75, 1.25) == 1.45773797371132511771853821938639577": +Test "hypot (0.75, 1.25)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "hypot (0x1.234566p-126, 0x1.234566p-126) == 1.891441686191081936598531534017449451173e-38": +Test "hypot (0x1.234566p-126, 0x1.234566p-126)": double: 1 idouble: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # j0 -Test "j0 (-0x1.001000001p+593) == -3.927269966354206207832593635798954916263e-90": +Test "j0 (-0x1.001000001p+593)": ildouble: 2 ldouble: 2 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j0 (0x1p1023) == -1.5665258060609012834424478437196679802783e-155": +Test "j0 (0x1p1023)": ildouble: 1 ldouble: 1 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": double: 1 float: 1 idouble: 1 @@ -5939,185 +5951,185 @@ ildouble: 1 ldouble: 1 # j1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (0x1p1023) == 8.2687542933709649327986678723012001545638e-155": +Test "j1 (0x1p1023)": ildouble: 1 ldouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 4 ldouble: 4 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (3, -1.0) == -0.0195633539826684059189053216217515083": +Test "jn (3, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 idouble: 1 -Test "jn (3, 1.0) == 0.0195633539826684059189053216217515083": +Test "jn (3, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 2 idouble: 3 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 4 ldouble: 4 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 ildouble: 2 ldouble: 2 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 ildouble: 4 ldouble: 4 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 2 float: 2 idouble: 2 @@ -6126,12 +6138,12 @@ ildouble: 7 ldouble: 7 # lgamma -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -6140,838 +6152,855 @@ ildouble: 3 ldouble: 3 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # log2 -Test "log2 (e) == M_LOG2El": +Test "log2 (e)": ildouble: 1 ldouble: 1 # pow -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 +# pow10 +Test "pow10 (-1)": +double: 1 +idouble: 1 +Test "pow10 (-305)": +double: 1 +idouble: 1 +Test "pow10 (-36)": +double: 1 +idouble: 1 +Test "pow10 (3)": +double: 1 +idouble: 1 +Test "pow10 (36)": +double: 1 +idouble: 1 + # pow_downward -Test "pow_downward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_downward (1.0625, 1.125)": ildouble: 1 ldouble: 1 -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 # pow_towardzero -Test "pow_towardzero (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_towardzero (1.0625, 1.125)": ildouble: 1 ldouble: 1 -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 -Test "pow_upward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_upward (1.5, 1.03125)": ildouble: 1 ldouble: 1 # sin -Test "sin (16.0) == -0.2879033166650652947844562482186175296207": +Test "sin (16.0)": ildouble: 2 ldouble: 2 # sin_downward -Test "sin_downward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_downward (1)": ildouble: 4 ldouble: 4 -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 -Test "sin_downward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_downward (2)": ildouble: 1 ldouble: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sin_downward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_downward (4)": ildouble: 1 ldouble: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sin_downward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_downward (8)": ildouble: 1 ldouble: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (2) == 0.9092974268256816953960198659117448427023": +Test "sin_towardzero (2)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (3) == 0.1411200080598672221007448028081102798469": +Test "sin_towardzero (3)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 -Test "sin_towardzero (8) == 0.9893582466233817778081235982452886721164": +Test "sin_towardzero (8)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 -Test "sin_upward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_upward (3)": ildouble: 1 ldouble: 1 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_upward (6)": ildouble: 1 ldouble: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 2": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/2, &sin_res, &cos_res) puts 0 in cos_res": +Test "sincos (pi/2) extra output 2": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh -Test "sinh (0.75) == 0.822316731935829980703661634446913849": +Test "sinh (0.75)": ildouble: 1 ldouble: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sinh_upward -Test "sinh_upward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_upward (23)": ildouble: 1 ldouble: 1 -Test "sinh_upward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_upward (24)": ildouble: 1 ldouble: 1 # sqrt -Test "sqrt (0.75) == 0.866025403784438646763723170752936183": +Test "sqrt (0.75)": double: 1 idouble: 1 -Test "sqrt (2) == M_SQRT2l": +Test "sqrt (2)": double: 1 idouble: 1 # tan -Test "tan (-0xc.908p-4) == -0.9997603425502441410973077452249560802034": +Test "tan (-0xc.908p-4)": ildouble: 2 ldouble: 2 -Test "tan (-0xc.90cp-4) == -0.9998823910588060302788513970802357770031": +Test "tan (-0xc.90cp-4)": ildouble: 2 ldouble: 2 -Test "tan (-0xc.90ep-4) == -0.9999434208994808753305784795924711152508": +Test "tan (-0xc.90ep-4)": ildouble: 2 ldouble: 2 -Test "tan (-0xc.90f8p-4) == -0.9999891957244072765118898375645469865764": +Test "tan (-0xc.90f8p-4)": ildouble: 2 ldouble: 2 -Test "tan (-0xc.90fcp-4) == -0.9999968250656122402859679132395522927393": +Test "tan (-0xc.90fcp-4)": ildouble: 1 ldouble: 1 -Test "tan (-0xc.90fd8p-4) == -0.9999996860835706212861509874451585282616": +Test "tan (-0xc.90fd8p-4)": ildouble: 1 ldouble: 1 -Test "tan (-0xc.90fdap-4) == -0.9999999245021033010474530133665235922808": +Test "tan (-0xc.90fdap-4)": ildouble: 1 ldouble: 1 -Test "tan (-0xc.92p-4) == -1.0004928571392300571266638743539017593717": +Test "tan (-0xc.92p-4)": ildouble: 1 ldouble: 1 -Test "tan (-0xc.9p-4) == -0.9995162902115457818029468900654150261381": +Test "tan (-0xc.9p-4)": ildouble: 1 ldouble: 1 -Test "tan (0xc.908p-4) == 0.9997603425502441410973077452249560802034": +Test "tan (0xc.908p-4)": ildouble: 2 ldouble: 2 -Test "tan (0xc.90cp-4) == 0.9998823910588060302788513970802357770031": +Test "tan (0xc.90cp-4)": ildouble: 2 ldouble: 2 -Test "tan (0xc.90ep-4) == 0.9999434208994808753305784795924711152508": +Test "tan (0xc.90ep-4)": ildouble: 2 ldouble: 2 -Test "tan (0xc.90f8p-4) == 0.9999891957244072765118898375645469865764": +Test "tan (0xc.90f8p-4)": ildouble: 2 ldouble: 2 -Test "tan (0xc.90fcp-4) == 0.9999968250656122402859679132395522927393": +Test "tan (0xc.90fcp-4)": ildouble: 1 ldouble: 1 -Test "tan (0xc.90fd8p-4) == 0.9999996860835706212861509874451585282616": +Test "tan (0xc.90fd8p-4)": ildouble: 1 ldouble: 1 -Test "tan (0xc.90fdap-4) == 0.9999999245021033010474530133665235922808": +Test "tan (0xc.90fdap-4)": ildouble: 1 ldouble: 1 -Test "tan (0xc.92p-4) == 1.0004928571392300571266638743539017593717": +Test "tan (0xc.92p-4)": ildouble: 1 ldouble: 1 -Test "tan (0xc.9p-4) == 0.9995162902115457818029468900654150261381": +Test "tan (0xc.9p-4)": ildouble: 1 ldouble: 1 -Test "tan (pi/4) == 1": +Test "tan (pi/4)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # tan_tonearest -Test "tan_tonearest (10) == 0.6483608274590866712591249330098086768169": +Test "tan_tonearest (10)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (4) == 1.1578212823495775831373424182673239231198": +Test "tan_tonearest (4)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (7) == 0.8714479827243187364564508896003135663222": +Test "tan_tonearest (7)": ildouble: 1 ldouble: 1 # tan_towardzero -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 -Test "tan_towardzero (6) == -0.2910061913847491570536995888681755428312": +Test "tan_towardzero (6)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (7) == 0.8714479827243187364564508896003135663222": +Test "tan_towardzero (7)": ildouble: 2 ldouble: 2 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # tan_upward -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": ildouble: 1 ldouble: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_upward (6)": ildouble: 1 ldouble: 1 -Test "tan_upward (7) == 0.8714479827243187364564508896003135663222": +Test "tan_upward (7)": ildouble: 1 ldouble: 1 -Test "tan_upward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_upward (9)": ildouble: 1 ldouble: 1 # tanh -Test "tanh (-0.75) == -0.635148952387287319214434357312496495": +Test "tanh (-0.75)": ildouble: 1 ldouble: 1 -Test "tanh (0.75) == 0.635148952387287319214434357312496495": +Test "tanh (0.75)": ildouble: 1 ldouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x0.fffffffffffff8p0) == -9.0071992547409924227843350984672961392521e+15": +Test "tgamma (-0x0.fffffffffffff8p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x0.ffffffp0) == -1.6777216422784419250710305882992376932423e+07": +Test "tgamma (-0x0.ffffffp0)": float: 1 ifloat: 1 -Test "tgamma (-0x1.000002p0) == 8.3886075772158332060084424806449513922858e+06": +Test "tgamma (-0x1.000002p0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.0a32a2p+5) == 1.8125267978155035272941154746083439329912e-37": +Test "tgamma (-0x1.0a32a2p+5)": float: 2 ifloat: 2 -Test "tgamma (-0x13.ffffep0) == 2.1550026214525536756224040483579183652119e-13": +Test "tgamma (-0x13.ffffep0)": float: 1 ifloat: 1 -Test "tgamma (-0x13.fffffffffffffffffffffffff8p0) == 1.0420893204640670202556853709074896123293e+12": +Test "tgamma (-0x13.fffffffffffffffffffffffff8p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x13.ffffffffffffp0) == 1.1569515572952029402736625857313236848570e-04": +Test "tgamma (-0x13.ffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x14.000000000001p0) == -1.1569515572951781096476686854873801225397e-04": +Test "tgamma (-0x14.000000000001p0)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tgamma (-0x14.00002p0) == -2.1549777908265594916405421768142757507179e-13": +Test "tgamma (-0x14.00002p0)": float: 1 ifloat: 1 -Test "tgamma (-0x1d.ffffep0) == 1.9765721589464867957912772592816027583176e-27": +Test "tgamma (-0x1d.ffffep0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1d.fffffffffffffffffffffffff8p0) == 9.5580541610429641982963434151488827190079e-03": +Test "tgamma (-0x1d.fffffffffffffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1d.ffffffffffffp0) == 1.0611571800204311628217068863959963842891e-18": +Test "tgamma (-0x1d.ffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1e.00000000000000000000000008p0) == -9.5580541610429641982963434151231128067179e-03": +Test "tgamma (-0x1e.00000000000000000000000008p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x1e.000000000001p0) == -1.0611571800204053929094168642022073530425e-18": +Test "tgamma (-0x1e.000000000001p0)": double: 3 idouble: 3 ildouble: 3 ldouble: 3 -Test "tgamma (-0x1e.00002p0) == -1.9765463890341964384070157599286498212650e-27": +Test "tgamma (-0x1e.00002p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x2.0000000000002p0) == -1.1258999068426235386078324507668462444260e+15": +Test "tgamma (-0x2.0000000000002p0)": double: 1 idouble: 1 -Test "tgamma (-0x2.000004p0) == -2.0971515386080557574407223895988378776747e+06": +Test "tgamma (-0x2.000004p0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.fffffcp0) == -6.9905087601970247876992248591045142913324e+05": +Test "tgamma (-0x2.fffffcp0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x27.fffffffffffep0) == 1.7249032006742266376460389310340465554361e-34": +Test "tgamma (-0x27.fffffffffffep0)": double: 1 idouble: 1 -Test "tgamma (-0x27.fffffffffffffffffffffffffp0) == 1.5536546823612837336494536911280147806523e-18": +Test "tgamma (-0x27.fffffffffffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.000000000002p0) == -1.7249032006741359094184881234822934593822e-34": +Test "tgamma (-0x28.000000000002p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.00004p0) == -3.2128372159115252365699015758097981155793e-43": +Test "tgamma (-0x28.00004p0)": double: 2 idouble: 2 -Test "tgamma (-0x29.0000000000000000000000001p0) == 3.7894016642958139845108626612656391824122e-20": +Test "tgamma (-0x29.0000000000000000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.00004p0) == 7.8361876024016854597745353972619195760515e-45": +Test "tgamma (-0x29.00004p0)": double: 1 idouble: 1 -Test "tgamma (-0x29.ffffcp0) == 1.8658121573125798145204120066590953505132e-46": +Test "tgamma (-0x29.ffffcp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.fffffffffffep0) == 1.0016859469652887505173040814397197718981e-37": +Test "tgamma (-0x29.fffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2a.0000000000000000000000001p0) == -9.0223849149900332964544349077751619246306e-22": +Test "tgamma (-0x2a.0000000000000000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3.000004p0) == 6.9905045731381300146131914617735687322025e+05": +Test "tgamma (-0x3.000004p0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (-0x3.fffffcp0) == 1.7476272942159602684441970627092458855771e+05": +Test "tgamma (-0x3.fffffcp0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x3.ffffffffffffep0) == 9.3824992236885396088236184658402406857503e+13": +Test "tgamma (-0x3.ffffffffffffep0)": double: 2 idouble: 2 -Test "tgamma (-0x31.fffffffffffep0) == 4.6273774273632946947805289899230181990085e-51": +Test "tgamma (-0x31.fffffffffffep0)": double: 3 idouble: 3 -Test "tgamma (-0x32.0000000000000000000000001p0) == -4.1679710515150795310771069868090576746248e-35": +Test "tgamma (-0x32.0000000000000000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x32.000000000002p0) == -4.6273774273630367887073532197576655720178e-51": +Test "tgamma (-0x32.000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.000008p0) == -8.7381270578483499672965708923121931082305e+04": +Test "tgamma (-0x4.000008p0)": float: 1 ifloat: 1 -Test "tgamma (-0x4.fffff8p0) == -1.7476280884325863043793087474680780379554e+04": +Test "tgamma (-0x4.fffff8p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x4.ffffffffffffcp0) == -9.3824992236885475509805702650262155809819e+12": +Test "tgamma (-0x4.ffffffffffffcp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.0000000000004p0) == 9.3824992236885191156860964016850034672946e+12": +Test "tgamma (-0x5.0000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.000008p0) == 1.7476252449031389167286893378510439443844e+04": +Test "tgamma (-0x5.000008p0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "tgamma (-0x5.ffffffffffffcp0) == 1.5637498706147581566449098589862357835505e+12": +Test "tgamma (-0x5.ffffffffffffcp0)": double: 1 idouble: 1 -Test "tgamma (-0x6.000008p0) == -2.9127085100239567622341538102130981196910e+03": +Test "tgamma (-0x6.000008p0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.fffff8p0) == -4.1610198723079349791939054365613377035519e+02": +Test "tgamma (-0x6.fffff8p0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.ffffffffffffcp0) == -2.2339283865925119357965832452642909859289e+11": +Test "tgamma (-0x6.ffffffffffffcp0)": double: 4 idouble: 4 ildouble: 2 ldouble: 2 -Test "tgamma (-0x63.fffffffffffcp0) == 7.5400833348840965463348754984345825364294e-145": +Test "tgamma (-0x63.fffffffffffcp0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x63.ffffffffffffffffffffffffep0) == 6.7915032994648558610510614163560656864280e-129": +Test "tgamma (-0x63.ffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x64.000000000004p0) == -7.5400833348831085791638490135462230991587e-145": +Test "tgamma (-0x64.000000000004p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.0000000000004p0) == 2.2339283865925039372192897706214475877342e+11": +Test "tgamma (-0x7.0000000000004p0)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.000008p0) == 4.1610118737306415004517215226199741948733e+02": +Test "tgamma (-0x7.000008p0)": double: 1 idouble: 1 -Test "tgamma (-0x7.fffff8p0) == 5.2012751504050764429534086402871289946986e+01": +Test "tgamma (-0x7.fffff8p0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "tgamma (-0x7.ffffffffffffcp0) == 2.7924104832406402297655703264222230055898e+10": +Test "tgamma (-0x7.ffffffffffffcp0)": double: 3 idouble: 3 ildouble: 3 ldouble: 3 -Test "tgamma (-0x8.00000000000000000000000004p0) == -1.2575898811787990094213325450153421028080e+26": +Test "tgamma (-0x8.00000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x8.00001p0) == -2.6006296115134418896533598545925084576702e+01": +Test "tgamma (-0x8.00001p0)": double: 2 idouble: 2 -Test "tgamma (-0x9.ffffffffffff8p0) == 1.5513391573559147700413058496716749249803e+08": +Test "tgamma (-0x9.ffffffffffff8p0)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tgamma (-0x9.fffffp0) == 2.8896008370721717567612135720915723136310e-01": +Test "tgamma (-0x9.fffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x96.000000000008p0) == -6.1582369322705655439003240743176243138734e-250": +Test "tgamma (-0x96.000000000008p0)": double: 1 idouble: 1 -Test "tgamma (-0xa.00001p0) == -2.8895878754728051776830454190076999107021e-01": +Test "tgamma (-0xa.00001p0)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tgamma (-2.5) == -9.4530872048294188122568932444861076415869e-01": +Test "tgamma (-2.5)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-3.5) == 2.7008820585226910892162552127103164690248e-01": +Test "tgamma (-3.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-4.5) == -6.0019601300504246427027893615784810422774e-02": +Test "tgamma (-4.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-5.5) == 1.0912654781909862986732344293779056440504e-02": +Test "tgamma (-5.5)": double: 1 idouble: 1 -Test "tgamma (-6.5) == -1.6788699664476712287280529682737009908468e-03": +Test "tgamma (-6.5)": float: 1 ifloat: 1 -Test "tgamma (-7.5) == 2.2384932885968949716374039576982679877958e-04": +Test "tgamma (-7.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (-8.5) == -2.6335215159963470254557693619979623385833e-05": +Test "tgamma (-8.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-9.5) == 2.7721279115751021320587045915768024616666e-06": +Test "tgamma (-9.5)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0x1.fffffep0) == 9.9999994960018563231526611134590489120697e-01": +Test "tgamma (0x1.fffffep0)": float: 1 ifloat: 1 -Test "tgamma (0x1.fffffffffffffp0) == 9.9999999999999990612301934456883679778984e-01": +Test "tgamma (0x1.fffffffffffffp0)": double: 1 idouble: 1 -Test "tgamma (0x1p-24) == 1.6777215422784394050795179874582764575261e+07": +Test "tgamma (0x1p-24)": float: 1 ifloat: 1 -Test "tgamma (0x1p-53) == 9.0071992547409914227843350984672492007618e+15": +Test "tgamma (0x1p-53)": double: 1 idouble: 1 -Test "tgamma (0x2.30a43cp+4) == 3.4027979115654976101247558405326779640190e+38": +Test "tgamma (0x2.30a43cp+4)": double: 1 idouble: 1 -Test "tgamma (0x2.fffffcp0) == 1.9999995599822108706107786027549565954046e+00": +Test "tgamma (0x2.fffffcp0)": float: 3 ifloat: 3 -Test "tgamma (0x3.fffffcp0) == 5.9999982031095793171233994481968816873643e+00": +Test "tgamma (0x3.fffffcp0)": float: 1 ifloat: 1 -Test "tgamma (0x3.ffffffffffffep0) == 5.9999999999999966530301828845138185025345e+00": +Test "tgamma (0x3.ffffffffffffep0)": double: 1 idouble: 1 -Test "tgamma (0x4.0000000000004p0) == 6.0000000000000066939396342309789716341613e+00": +Test "tgamma (0x4.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x4.fffff8p0) == 2.3999982763857938712639837029547357501709e+01": +Test "tgamma (0x4.fffff8p0)": float: 1 ifloat: 1 -Test "tgamma (0x4.ffffffffffffcp0) == 2.3999999999999967895170944875373910918544e+01": +Test "tgamma (0x4.ffffffffffffcp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x5.0000000000004p0) == 2.4000000000000032104829055124673225982803e+01": +Test "tgamma (0x5.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x5.000008p0) == 2.4000017236155647574166073485628713443799e+01": +Test "tgamma (0x5.000008p0)": float: 3 ifloat: 3 -Test "tgamma (0x5.fffff8p0) == 1.1999990237520611552119807476573441975106e+02": +Test "tgamma (0x5.fffff8p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0x6.0000000000004p0) == 1.2000000000000018184042734842640022086408e+02": +Test "tgamma (0x6.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x6.000008p0) == 1.2000009762487825358530770343720418162783e+02": +Test "tgamma (0x6.000008p0)": float: 2 ifloat: 2 -Test "tgamma (0x6.fffff8p0) == 7.1999935703082425988147448928288557689866e+02": +Test "tgamma (0x6.fffff8p0)": double: 1 idouble: 1 -Test "tgamma (0x6.ffffffffffffcp0) == 7.1999999999999880237602554542848858572672e+02": +Test "tgamma (0x6.ffffffffffffcp0)": double: 4 idouble: 4 ildouble: 1 ldouble: 1 -Test "tgamma (0x7.0000000000004p0) == 7.2000000000000119762397445457359071259652e+02": +Test "tgamma (0x7.0000000000004p0)": double: 4 idouble: 4 -Test "tgamma (0x7.000008p0) == 7.2000064296977505705636258629805621178587e+02": +Test "tgamma (0x7.000008p0)": double: 1 idouble: 1 -Test "tgamma (0x7.fffff8p0) == 5.0399951558933225045148935487583089307135e+03": +Test "tgamma (0x7.fffff8p0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (0x7.ffffffffffffcp0) == 5.0399999999999909771437166339103165198442e+03": +Test "tgamma (0x7.ffffffffffffcp0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (0x8.00001p0) == 5.0400096882277802019946778420223050233915e+03": +Test "tgamma (0x8.00001p0)": double: 2 idouble: 2 -Test "tgamma (0xa.b9fd72b0fb238p+4) == 1.7976931348622298700886249281842651388250e+308": +Test "tgamma (0xa.b9fd72b0fb238p+4)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tgamma (0xa.b9fd72b0fb23a9ddbf0d3804f4p+4) == 1.7976931348623158079372897140307719334857e+308": +Test "tgamma (0xa.b9fd72b0fb23a9ddbf0d3804f4p+4)": ildouble: 1 ldouble: 1 -Test "tgamma (10) == 362880": +Test "tgamma (10)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (18.5) == 1.4986120533153361177371791123515513270334e+15": +Test "tgamma (18.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (19.5) == 2.7724322986333718178137813578503699550119e+16": +Test "tgamma (19.5)": double: 2 idouble: 2 -Test "tgamma (2.5) == 1.3293403881791370204736256125058588870982e+00": +Test "tgamma (2.5)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (23.5) == 5.3613035875444147334274983856108155717836e+21": +Test "tgamma (23.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (29.5) == 1.6348125198274266444378807806868221866931e+30": +Test "tgamma (29.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (3) == 2": +Test "tgamma (3)": float: 1 ifloat: 1 -Test "tgamma (3.5) == 3.3233509704478425511840640312646472177454e+00": +Test "tgamma (3.5)": float: 2 ifloat: 2 -Test "tgamma (33.5) == 1.5058569756267018925121415841930137587110e+36": +Test "tgamma (33.5)": ildouble: 1 ldouble: 1 -Test "tgamma (34.5) == 5.0446208683494513399156743070465960916817e+37": +Test "tgamma (34.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (4) == 6": +Test "tgamma (4)": float: 1 ifloat: 1 -Test "tgamma (4.5) == 1.1631728396567448929144224109426265262109e+01": +Test "tgamma (4.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (6) == 120": +Test "tgamma (6)": float: 1 ifloat: 1 -Test "tgamma (6.5) == 2.8788527781504436099631954670830006523720e+02": +Test "tgamma (6.5)": float: 1 ifloat: 1 -Test "tgamma (7) == 720": +Test "tgamma (7)": double: 1 idouble: 1 -Test "tgamma (7.5) == 1.8712543057977883464760770536039504240418e+03": +Test "tgamma (7.5)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (8) == 5040": +Test "tgamma (8)": double: 1 idouble: 1 -Test "tgamma (8.5) == 1.4034407293483412598570577902029628180313e+04": +Test "tgamma (8.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (9) == 40320": +Test "tgamma (9)": double: 1 idouble: 1 -Test "tgamma (9.5) == 1.1929246199460900708784991216725183953266e+05": +Test "tgamma (9.5)": double: 1 float: 1 idouble: 1 @@ -6980,78 +7009,78 @@ ildouble: 1 ldouble: 1 # y0 -Test "y0 (0.125) == -1.38968062514384052915582277745018693": +Test "y0 (0.125)": ildouble: 1 ldouble: 1 -Test "y0 (0.75) == -0.137172769385772397522814379396581855": +Test "y0 (0.75)": ildouble: 1 ldouble: 1 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-100) == -4.420092432563900590456563035154802121284e+1": +Test "y0 (0x1p-100)": ildouble: 1 ldouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": double: 1 idouble: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-60) == -2.6550076313426878432849115782108205929120e+1": +Test "y0 (0x1p-60)": float: 1 ifloat: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 idouble: 1 -Test "y0 (0x1p1023) == 8.2687542933709649327986678723012001545638e-155": +Test "y0 (0x1p1023)": ildouble: 1 ldouble: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (2.0) == 0.510375672649745119596606592727157873": +Test "y0 (2.0)": double: 1 idouble: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -7060,44 +7089,44 @@ ildouble: 1 ldouble: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0x1.001000001p+593) == 3.927269966354206207832593635798954916263e-90": +Test "y1 (0x1.001000001p+593)": ildouble: 2 ldouble: 2 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 -Test "y1 (0x1p-20) == -6.6754421443450423911167962313100637952285e+05": +Test "y1 (0x1p-20)": ildouble: 1 ldouble: 1 -Test "y1 (0x1p1023) == 1.5665258060609012834424478437196679802783e-155": +Test "y1 (0x1p1023)": ildouble: 1 ldouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 2 float: 1 idouble: 2 ifloat: 2 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 @@ -7106,105 +7135,105 @@ ildouble: 1 ldouble: 1 # yn -Test "yn (0, 0.125) == -1.38968062514384052915582277745018693": +Test "yn (0, 0.125)": ildouble: 1 ldouble: 1 -Test "yn (0, 0.75) == -0.137172769385772397522814379396581855": +Test "yn (0, 0.75)": ildouble: 1 ldouble: 1 -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (0, 2.0) == 0.510375672649745119596606592727157873": +Test "yn (0, 2.0)": double: 1 idouble: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 2 ifloat: 2 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": float: 2 ifloat: 2 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 2 float: 2 idouble: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": float: 1 ifloat: 1 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 @@ -7774,6 +7803,10 @@ ildouble: 1 ldouble: 1 Function: "gamma": +double: 1 +float: 2 +idouble: 1 +ifloat: 2 ildouble: 1 ldouble: 1 @@ -7845,6 +7878,10 @@ ifloat: 1 ildouble: 1 ldouble: 1 +Function: "pow10": +double: 1 +idouble: 1 + Function: "pow_downward": float: 1 ifloat: 1 diff --git a/libc/sysdeps/powerpc/powerpc32/dl-machine.c b/libc/sysdeps/powerpc/powerpc32/dl-machine.c index 1863e3b71..475d238ba 100644 --- a/libc/sysdeps/powerpc/powerpc32/dl-machine.c +++ b/libc/sysdeps/powerpc/powerpc32/dl-machine.c @@ -511,8 +511,7 @@ __process_machine_rela (struct link_map *map, strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr, (char *) finaladdr, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/sysdeps/powerpc/powerpc64/dl-machine.h b/libc/sysdeps/powerpc/powerpc64/dl-machine.h index 14ade21d9..059fdafd5 100644 --- a/libc/sysdeps/powerpc/powerpc64/dl-machine.h +++ b/libc/sysdeps/powerpc/powerpc64/dl-machine.h @@ -734,8 +734,7 @@ elf_machine_rela (struct link_map *map, _dl_error_printf ("%s: Symbol `%s' has different size" \ " in shared object," \ " consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (char *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/sysdeps/powerpc/sys/platform/ppc.h b/libc/sysdeps/powerpc/sys/platform/ppc.h index 740831e67..81f3bf9bf 100644 --- a/libc/sysdeps/powerpc/sys/platform/ppc.h +++ b/libc/sysdeps/powerpc/sys/platform/ppc.h @@ -50,4 +50,66 @@ __ppc_get_timebase (void) #endif } +/* The following functions provide hints about the usage of shared processor + resources, as defined in ISA 2.06 and newer. */ + +/* Provides a hint that performance will probably be improved if shared + resources dedicated to the executing processor are released for use by other + processors. */ +static inline void +__ppc_yield (void) +{ + __asm__ volatile ("or 27,27,27"); +} + +/* Provides a hint that performance will probably be improved if shared + resources dedicated to the executing processor are released until + all outstanding storage accesses to caching-inhibited storage have been + completed. */ +static inline void +__ppc_mdoio (void) +{ + __asm__ volatile ("or 29,29,29"); +} + +/* Provides a hint that performance will probably be improved if shared + resources dedicated to the executing processor are released until all + outstanding storage accesses to cacheable storage for which the data is not + in the cache have been completed. */ +static inline void +__ppc_mdoom (void) +{ + __asm__ volatile ("or 30,30,30"); +} + + +/* ISA 2.05 and beyond support the Program Priority Register (PPR) to adjust + thread priorities based on lock acquisition, wait and release. The ISA + defines the use of form 'or Rx,Rx,Rx' as the way to modify the PRI field. + The unprivileged priorities are: + Rx = 1 (low) + Rx = 2 (medium) + Rx = 6 (medium-low/normal) + The 'or' instruction form is a nop in previous hardware, so it is safe to + use unguarded. The default value is 'medium'. + */ + +static inline void +__ppc_set_ppr_med (void) +{ + __asm__ volatile ("or 2,2,2"); +} + +static inline void +__ppc_set_ppr_med_low (void) +{ + __asm__ volatile ("or 6,6,6"); +} + +static inline void +__ppc_set_ppr_low (void) +{ + __asm__ volatile ("or 1,1,1"); +} + #endif /* sys/platform/ppc.h */ diff --git a/libc/sysdeps/s390/fpu/libm-test-ulps b/libc/sysdeps/s390/fpu/libm-test-ulps index 1015ca015..cc5349bbb 100644 --- a/libc/sysdeps/s390/fpu/libm-test-ulps +++ b/libc/sysdeps/s390/fpu/libm-test-ulps @@ -1,19 +1,19 @@ # Begin of automatic generation # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 @@ -22,19 +22,19 @@ ildouble: 1 ldouble: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 @@ -43,181 +43,181 @@ ildouble: 1 ldouble: 1 # acos_upward -Test "acos_upward (-0) == pi/2": +Test "acos_upward (-0)": ildouble: 1 ldouble: 1 -Test "acos_upward (-1) == pi": +Test "acos_upward (-1)": ildouble: 1 ldouble: 1 -Test "acos_upward (0) == pi/2": +Test "acos_upward (0)": ildouble: 1 ldouble: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (-1.0) == -pi/2": +Test "asin_downward (-1.0)": ildouble: 1 ldouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 # asin_upward -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 -Test "asin_upward (1.0) == pi/2": +Test "asin_upward (1.0)": ildouble: 1 ldouble: 1 # atan2 -Test "atan2 (-0.00756827042671106339, -.001792735857538728036) == -1.80338464113663849327153994379639112": +Test "atan2 (-0.00756827042671106339, -.001792735857538728036)": ildouble: 1 ldouble: 1 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Real part of: cacos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: cacos (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 @@ -226,236 +226,236 @@ ildouble: 1 ldouble: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p500 + 1.0 i) == -1.570796326794896619231321691639751442099 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p500 - 1.0 i) == -1.570796326794896619231321691639751442099 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p5000 + 1.0 i) == -1.570796326794896619231321691639751442099 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p5000 - 1.0 i) == -1.570796326794896619231321691639751442099 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1p500 i) == -3.054936363499604682051979393213617699789e-151 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1p5000 i) == -7.079811261048172892385615158694057552948e-1506 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1p500 i) == -3.054936363499604682051979393213617699789e-151 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1p5000 i) == -7.079811261048172892385615158694057552948e-1506 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: casin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 + 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 + 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp16383 + 0x1.fp16383 i) == 7.853981633974483096156608458198757210493e-1 + 1.135753137836666928715489992987020363057e4 i": +Test "Imaginary part of: casin (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p500 + 1.0 i) == 1.570796326794896619231321691639751442099 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p500 - 1.0 i) == 1.570796326794896619231321691639751442099 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p5000 + 1.0 i) == 1.570796326794896619231321691639751442099 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p5000 - 1.0 i) == 1.570796326794896619231321691639751442099 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1p500 i) == 3.054936363499604682051979393213617699789e-151 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1p5000 i) == 7.079811261048172892385615158694057552948e-1506 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1p500 i) == 3.054936363499604682051979393213617699789e-151 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1p5000 i) == 7.079811261048172892385615158694057552948e-1506 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 @@ -464,1012 +464,1012 @@ ildouble: 1 ldouble: 1 # casinh -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p500 + 1.0 i) == -3.472667374605326000180332928505464606058e2 + 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (-0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p500 - 1.0 i) == -3.472667374605326000180332928505464606058e2 - 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (-0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p5000 + 1.0 i) == -3.466429049980286492395577839412341016946e3 + 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (-0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p5000 - 1.0 i) == -3.466429049980286492395577839412341016946e3 - 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (-0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1p500 i) == -3.472667374605326000180332928505464606058e2 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1p5000 i) == -3.466429049980286492395577839412341016946e3 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1p500 i) == -3.472667374605326000180332928505464606058e2 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1p5000 i) == -3.466429049980286492395577839412341016946e3 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp16383 + 0x1.fp16383 i) == 1.135753137836666928715489992987020363057e4 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p500 + 1.0 i) == 3.472667374605326000180332928505464606058e2 + 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p500 - 1.0 i) == 3.472667374605326000180332928505464606058e2 - 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p5000 + 1.0 i) == 3.466429049980286492395577839412341016946e3 + 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p5000 - 1.0 i) == 3.466429049980286492395577839412341016946e3 - 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1p500 i) == 3.472667374605326000180332928505464606058e2 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1p5000 i) == 3.466429049980286492395577839412341016946e3 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1p500 i) == 3.472667374605326000180332928505464606058e2 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1p5000 i) == 3.466429049980286492395577839412341016946e3 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # catan -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (0.75 + 1.25 i) == 1.10714871779409050301706546017853704 + 0.549306144334054845697622618461262852 i": +Test "Imaginary part of: catan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Imaginary part of: catanh (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 # cbrt -Test "cbrt (-0.001) == -0.1": +Test "cbrt (-0.001)": ildouble: 1 ldouble: 1 -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 11357.25 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (-0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 11357.25 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (-0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Real part of: ccos (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 11357.25 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 11357.25 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0x1p-16434 + 22730 i) == inf - 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: ccos (0x1p-16434 + 22730 i)": ildouble: 1 ldouble: 1 # ccosh -Test "Imaginary part of: ccosh (-11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (-11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (-11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (22730 + 0x1p-16434 i) == inf + 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: ccosh (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cexp -Test "Imaginary part of: cexp (-10000 + 0x1p16383 i) == 1.045876464564882298442774542991176546722e-4343 + 4.421154026488516836023811173959413420548e-4344 i": +Test "Imaginary part of: cexp (-10000 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Real part of: cexp (-2.0 - 3.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-720 + 0.75 i) == 1.486960657116368433685753325516638551722e-313 + 1.385247284245720590980701226843815229385e-313 i": +Test "Imaginary part of: cexp (-720 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (22730 + 0x1p-16434 i) == inf + 2.435706297811211974162115164702304105374e4924 i": +Test "Imaginary part of: cexp (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16494 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16494 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16494 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16494 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16494 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16494 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 709.8942846690411016323109979483151967689 + 0.4636476090008061606231772164674799632783 i": +Test "Imaginary part of: clog (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i) == 11356.83823118610934184548269774874545400 + pi/4 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16494 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16494 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 3.2047474274603604594851472963586149973093e-29 + 1.4422922682185099608731642353544207976604 i": +Test "Imaginary part of: clog (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16494 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16494 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16494 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16494 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i) == -1.1931267660846218205882675852805793644095e-36 + 1.2402109774337032400594953899784058127412 i": +Test "Imaginary part of: clog (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2ede88p-23 + 0x771c3fp-23 i) == -4.4764192352906350039050902870893173560494e-13 + 1.1959106857549200806818600493552847793381 i": +Test "Imaginary part of: clog (0x2ede88p-23 + 0x771c3fp-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i) == -1.0509738482436128031927971874674370984602e-45 + 1.0509191467640012308402149909370784281448 i": +Test "Imaginary part of: clog (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x4d4ep-15 + 0x6605p-15 i) == -1.6298145321400412054744424587143483169412e-08 + 0.9223574537155056772124552172295398141249 i": +Test "Imaginary part of: clog (0x4d4ep-15 + 0x6605p-15 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i) == -5.2000108498455368032511404449795741611813e-32 + 1.5288921536982513453421343495466824420259 i": +Test "Imaginary part of: clog (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 8.3076914081087805757422664530653247447136e-30 + 1.2072712126771536614482822173033535043206 i": +Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x659feap-24 + 0xeaf6f9p-24 i) == 3.7303493627403868207597214252239749960738e-14 + 1.1625816408046866464773042283673653469061 i": +Test "Imaginary part of: clog (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6771f22c64ed551b857c128b4cp-105 + 0x1f570e7a13cc3cf2f44fd793ea1p-105 i) == -1.4281333889622737316199756373421183559948e-62 + 1.3673546561165378090903506783353927980633 i": +Test "Imaginary part of: clog (0x6771f22c64ed551b857c128b4cp-105 + 0x1f570e7a13cc3cf2f44fd793ea1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 2.4244570985709679851855191080208817099132e-37 + 1.1393074519572050614551047548718495655972 i": +Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i) == -9.7375017988218644730510244778042114638107e-30 + 0.9790637929494922564724108399524154766631 i": +Test "Real part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x9b57bp-20 + 0xcb7b4p-20 i) == -3.9563019528687610863490232935890272740908e-11 + 0.9187593477446338910857133065497364950682 i": +Test "Imaginary part of: clog (0x9b57bp-20 + 0xcb7b4p-20 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i) == 4.6017338806965821566734340588575402712716e-67 + 1.3547418904611758959096647942223384691728 i": +Test "Imaginary part of: clog (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i) == 6.6255694866654064502633121109394710807528e-66 + 1.0526409614996288387567810726095850312049 i": +Test "Imaginary part of: clog (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 5.3718272201930019901317065495843842735179e-26 + 1.0503831592447830576186444373011142397404 i": +Test "Imaginary part of: clog (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Real part of: clog10 (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Imaginary part of: clog10 (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i) == 4.285899851347756186652871946325962330640e-19 + 4.611541215247321502041995872887317363241e-302 i": +Test "Real part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i) == 4.285899851347756186652871946325962330640e-19 + 4.611541215247321502041995872887317363241e-302 i": +Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-60 i) == 4.285899851347756188767674032946882584784e-19 + 4.285899850759344225805480528847018395861e-19 i": +Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-60 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Real part of: clog10 (0x1.234566p-50 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Real part of: clog10 (0x1.234566p-60 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 308.4052305577487344482591243175787477115 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 308.3031705664207720674749211936626341569 + 0.2013595981366865903254995612594728746470 i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i) == 4932.212175672014259683102930239951947672 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i) == 4932.112944269463028900262609694408579449 + 0.2069271710841128115912940666587802677383 i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1415bcaf2105940d49a636e98ae59p-115 + 0x7e6a150adfcd1b0921d44b31f40f4p-115 i) == 1.1288799405048268615023706955013387413519e-67 + 0.6137587762850841972073301550420510507903 i": +Test "Real part of: clog10 (0x1415bcaf2105940d49a636e98ae59p-115 + 0x7e6a150adfcd1b0921d44b31f40f4p-115 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i) == 4.4163015461643576961232672330852798804976e-31 + 0.3564851427422832755956993418877523303529 i": +Test "Imaginary part of: clog10 (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Real part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i) == -322.8546703496198318667349645920187712089 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i) == -4.5643214291682663316715446865040356750881e-46 + 0.4564083863660793840592614609053162690362 i": +Test "Imaginary part of: clog10 (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Imaginary part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i) == 2.7822833698845776001753149807484078521508e-37 + 0.3992725998539071066769046272515417679815 i": +Test "Real part of: clog10 (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i) == -2.2583360179249556400630343805573865814771e-32 + 0.6639894257763289307423302343317622430835 i": +Test "Real part of: clog10 (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i) == -1.0146400362652473358437501879334790111898e-37 + 0.5149047982335273098246594109614460842099 i": +Test "Real part of: clog10 (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i) == 1.8804859395820231849002915747252695375405e-63 + 0.6404513901551516189871978418046651877394 i": +Test "Real part of: clog10 (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Real part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 1.0529283395205396881397407610630442563938e-37 + 0.4947949395762683446121140513971996916447 i": +Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i) == 1.9985076315737626043096596036300177494613e-67 + 0.5883569274304683249184005177865521205198 i": +Test "Real part of: clog10 (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i) == 2.8774482675253468630312378575186855052697e-66 + 0.4571561610046221605554903008571429975493 i": +Test "Imaginary part of: clog10 (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 @@ -1478,192 +1478,192 @@ ildouble: 1 ldouble: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 -Test "cos_downward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_downward (10)": ildouble: 1 ldouble: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_downward (6)": ildouble: 1 ldouble: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cos_towardzero -Test "cos_towardzero (10) == -0.8390715290764524522588639478240648345199": +Test "cos_towardzero (10)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (6) == 0.9601702866503660205456522979229244054519": +Test "cos_towardzero (6)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cos_upward -Test "cos_upward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_upward (1)": ildouble: 1 ldouble: 1 -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 -Test "cos_upward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_upward (4)": ildouble: 1 ldouble: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_tonearest -Test "cosh_tonearest (22) == 1792456423.065795780980053377632656584997": +Test "cosh_tonearest (22)": ildouble: 1 ldouble: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_upward -Test "cosh_upward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_upward (22)": ildouble: 1 ldouble: 1 -Test "cosh_upward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_upward (23)": ildouble: 1 ldouble: 1 -Test "cosh_upward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_upward (24)": ildouble: 1 ldouble: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 4 ldouble: 4 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 ildouble: 2 ldouble: 2 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 5 idouble: 1 ifloat: 5 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 @@ -1672,910 +1672,910 @@ ildouble: 1 ldouble: 1 # csin -Test "Real part of: csin (-0.75 + 11357.25 i) == -8.385498349388321535962327491346664141020e4931 + 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (-0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 11357.25 i) == -8.385498349388321535962327491346664141020e4931 - 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (-0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-2 - 3 i) == -9.15449914691142957346729954460983256 + 4.16890695996656435075481305885375484 i": +Test "Imaginary part of: csin (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Real part of: csin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 11357.25 i) == 8.385498349388321535962327491346664141020e4931 + 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 11357.25 i) == 8.385498349388321535962327491346664141020e4931 - 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 -Test "Real part of: csin (0x1p-16434 + 22730 i) == 1.217853148905605987081057582351152052687e4924 + inf i": +Test "Real part of: csin (0x1p-16434 + 22730 i)": ildouble: 1 ldouble: 1 # csinh -Test "Imaginary part of: csinh (-11357.25 + 0.75 i) == -9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (-11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-11357.25 - 0.75 i) == -9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (-11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Real part of: csinh (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (22730 + 0x1p-16434 i) == inf + 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: csinh (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # csqrt -Test "Real part of: csqrt (-0x1.0000000000000000000000000001p-16382 - 0x1.0000000000000000000000000001p-16382 i) == 8.344545284118961663847948339519226074126e-2467 - 2.014551439675644900022606748976158925145e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000000000000000001p-16382 - 0x1.0000000000000000000000000001p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i) == 6.788430486774966350907249113759995429568e-155 - 1.638872094839911521020410942677082920935e-154 i": +Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0.75 + 1.25 i) == 1.05065169626078392338656675760808326 + 0.594868882070379067881984030639932657 i": +Test "Imaginary part of: csqrt (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i) == 2.014551439675644900022606748976158925145e-2466 + 8.344545284118961663847948339519226074126e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i) == 1.638872094839911521020410942677082920935e-154 + 6.788430486774966350907249113759995429568e-155 i": +Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Real part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1p+16383 i) == 1.106698967236475180613254276996359485630e+2466 + 2.687568007603946993388538156299100955642e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-16440 + 0x1p-16441 i) == 3.514690655930285351254618340783294558136e-2475 + 8.297059146828716918029689466551384219370e-2476 i": +Test "Imaginary part of: csqrt (0x1p-16440 + 0x1p-16441 i)": ildouble: 1 ldouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Real part of: ctan (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Imaginary part of: ctan (0x1p1023 + 1 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Real part of: ctan (0x1p127 + 1 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Real part of: ctan (0x1p16383 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Imaginary part of: ctan (0x1p16383 + 1 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 355 i) == 8.140551093483276762350406321792653551513e-309 + 1.0 i": +Test "Real part of: ctan (1 + 355 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 365 i) == 1.677892637497921890115075995898773550884e-317 + 1.0 i": +Test "Real part of: ctan (1 + 365 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 45 i) == 1.490158918874345552942703234806348520895e-39 + 1.000000000000000000000000000000000000001 i": +Test "Real part of: ctan (1 + 45 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 47 i) == 2.729321264492904590777293425576722354636e-41 + 1.0 i": +Test "Real part of: ctan (1 + 47 i)": ildouble: 1 ldouble: 1 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 # ctan_tonearest -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 ifloat: 2 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Real part of: ctanh (1 + 0x1p1023 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Imaginary part of: ctanh (1 + 0x1p127 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Real part of: ctanh (1 + 0x1p16383 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Imaginary part of: ctanh (1 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (355 + 1 i) == 1.0 + 8.140551093483276762350406321792653551513e-309 i": +Test "Imaginary part of: ctanh (355 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (365 + 1 i) == 1.0 + 1.677892637497921890115075995898773550884e-317 i": +Test "Imaginary part of: ctanh (365 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (45 + 1 i) == 1.000000000000000000000000000000000000001 + 1.490158918874345552942703234806348520895e-39 i": +Test "Imaginary part of: ctanh (45 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (47 + 1 i) == 1.0 + 2.729321264492904590777293425576722354636e-41 i": +Test "Imaginary part of: ctanh (47 + 1 i)": ildouble: 1 ldouble: 1 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 4 ldouble: 4 -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 2 ldouble: 2 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_upward -Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0.75) == 0.288844366346484868401062165408589223": +Test "erfc (0.75)": float: 1 ifloat: 1 -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "erfc (0x1.ffffc8p+2) == 1.122671365033056305522366683719541099329e-29": +Test "erfc (0x1.ffffc8p+2)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (27.0) == 0.523704892378925568501606768284954709e-318": +Test "erfc (27.0)": ildouble: 1 ldouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 1 idouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 1 idouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 -Test "exp10 (4932) == 1.0e4932": +Test "exp10 (4932)": ildouble: 1 ldouble: 1 # exp2 -Test "exp2 (100.5) == 1.792728671193156477399422023278661496394e+30": +Test "exp2 (100.5)": ildouble: 1 ldouble: 1 # exp_downward -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_towardzero -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # expm1 -Test "expm1 (-79.0) == -0.9999999999999999999999999999999999509391": +Test "expm1 (-79.0)": ildouble: 1 ldouble: 1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # gamma -Test "gamma (-0.5) == log(2*sqrt(pi))": +Test "gamma (-0.5)": ildouble: 1 ldouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-0x1.001000001p+593) == -3.927269966354206207832593635798954916263e-90": +Test "j0 (-0x1.001000001p+593)": ildouble: 1 ldouble: 1 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": ildouble: 2 ldouble: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # j1 -Test "j1 (-1.0) == -0.440050585744933515959682203718914913": +Test "j1 (-1.0)": ildouble: 1 ldouble: 1 -Test "j1 (0.75) == 0.349243602174862192523281016426251335": +Test "j1 (0.75)": ildouble: 1 ldouble: 1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (1.0) == 0.440050585744933515959682203718914913": +Test "j1 (1.0)": ildouble: 1 ldouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": ildouble: 2 ldouble: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (1, -1.0) == -0.440050585744933515959682203718914913": +Test "jn (1, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (1, 0.75) == 0.349243602174862192523281016426251335": +Test "jn (1, 0.75)": ildouble: 1 ldouble: 1 -Test "jn (1, 1.0) == 0.440050585744933515959682203718914913": +Test "jn (1, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 5 ldouble: 5 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 ildouble: 3 ldouble: 3 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 ildouble: 8 ldouble: 8 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 @@ -2584,17 +2584,17 @@ ildouble: 3 ldouble: 3 # lgamma -Test "lgamma (-0.5) == log(2*sqrt(pi))": +Test "lgamma (-0.5)": ildouble: 1 ldouble: 1 -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -2603,433 +2603,433 @@ ildouble: 1 ldouble: 1 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # log2 -Test "log2 (0.75) == -.415037499278843818546261056052183492": +Test "log2 (0.75)": ildouble: 1 ldouble: 1 # pow -Test "pow (0x0.fffffffffffff8p0, -0x1.23456789abcdfp62) == 9.8826311568054561811190162420900667121992e+252": +Test "pow (0x0.fffffffffffff8p0, -0x1.23456789abcdfp62)": ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (10.0, -4930.0) == 1e-4930": +Test "pow (10.0, -4930.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4929.0) == 1e4929": +Test "pow (10.0, 4929.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4930.0) == 1e4930": +Test "pow (10.0, 4930.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4931.0) == 1e4931": +Test "pow (10.0, 4931.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4932.0) == 1e4932": +Test "pow (10.0, 4932.0)": ildouble: 1 ldouble: 1 -Test "pow (1e4932, 0.75) == 1e3699": +Test "pow (1e4932, 0.75)": ildouble: 1 ldouble: 1 # pow_downward -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 # pow_towardzero -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_downward -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 -Test "sin_downward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_downward (2)": ildouble: 1 ldouble: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_downward (4)": ildouble: 1 ldouble: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 -Test "sin_downward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_downward (8)": ildouble: 1 ldouble: 1 -Test "sin_downward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_downward (9)": ildouble: 1 ldouble: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 -Test "sin_tonearest (3) == 0.1411200080598672221007448028081102798469": +Test "sin_tonearest (3)": ildouble: 1 ldouble: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (2) == 0.9092974268256816953960198659117448427023": +Test "sin_towardzero (2)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (3) == 0.1411200080598672221007448028081102798469": +Test "sin_towardzero (3)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (8) == 0.9893582466233817778081235982452886721164": +Test "sin_towardzero (8)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_upward (10)": ildouble: 1 ldouble: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 -Test "sin_upward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_upward (3)": ildouble: 1 ldouble: 1 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 -Test "sin_upward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_upward (6)": ildouble: 1 ldouble: 1 -Test "sin_upward (7) == 0.6569865987187890903969990915936351779369": +Test "sin_upward (7)": ildouble: 1 ldouble: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 # sinh_upward -Test "sinh_upward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_upward (22)": ildouble: 1 ldouble: 1 -Test "sinh_upward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_upward (23)": ildouble: 1 ldouble: 1 -Test "sinh_upward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_upward (24)": ildouble: 1 ldouble: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_towardzero -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (6) == -0.2910061913847491570536995888681755428312": +Test "tan_towardzero (6)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": float: 1 ifloat: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_upward (2)": ildouble: 1 ldouble: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (4) == 1.1578212823495775831373424182673239231198": +Test "tan_upward (4)": ildouble: 1 ldouble: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_upward (6)": ildouble: 1 ldouble: 1 -Test "tan_upward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_upward (9)": ildouble: 1 ldouble: 1 # tanh -Test "tanh (-0.75) == -0.635148952387287319214434357312496495": +Test "tanh (-0.75)": ildouble: 1 ldouble: 1 -Test "tanh (-1.0) == -0.7615941559557648881194582826047935904": +Test "tanh (-1.0)": ildouble: 1 ldouble: 1 -Test "tanh (0.75) == 0.635148952387287319214434357312496495": +Test "tanh (0.75)": ildouble: 1 ldouble: 1 -Test "tanh (1.0) == 0.7615941559557648881194582826047935904": +Test "tanh (1.0)": ildouble: 1 ldouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (4) == 6": +Test "tgamma (4)": ildouble: 1 ldouble: 1 # y0 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-60) == -2.6550076313426878432849115782108205929120e+1": +Test "y0 (0x1p-60)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "y0 (2.0) == 0.510375672649745119596606592727157873": +Test "y0 (2.0)": double: 1 idouble: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -3038,46 +3038,46 @@ ildouble: 3 ldouble: 3 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0.75) == -1.03759455076928541973767132140642198": +Test "y1 (0.75)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.001000001p+593) == 3.927269966354206207832593635798954916263e-90": +Test "y1 (0x1.001000001p+593)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y1 (0x1p-30) == -6.8356527557643159612937462812258975438856e+08": +Test "y1 (0x1p-30)": ildouble: 1 ldouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 @@ -3086,110 +3086,110 @@ ildouble: 1 ldouble: 1 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (0, 2.0) == 0.510375672649745119596606592727157873": +Test "yn (0, 2.0)": double: 1 idouble: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 0.75) == -1.03759455076928541973767132140642198": +Test "yn (1, 0.75)": ildouble: 1 ldouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 5 ldouble: 5 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 2 idouble: 2 ildouble: 2 ldouble: 2 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/sysdeps/s390/s390-32/dl-machine.h b/libc/sysdeps/s390/s390-32/dl-machine.h index 544f843d8..aa8f1a5f1 100644 --- a/libc/sysdeps/s390/s390-32/dl-machine.h +++ b/libc/sysdeps/s390/s390-32/dl-machine.h @@ -383,8 +383,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc, strtab = (const char *) D_PTR(map,l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/sysdeps/s390/s390-64/dl-machine.h b/libc/sysdeps/s390/s390-64/dl-machine.h index 0504eb6b7..32f7a2cb2 100644 --- a/libc/sysdeps/s390/s390-64/dl-machine.h +++ b/libc/sysdeps/s390/s390-64/dl-machine.h @@ -361,8 +361,7 @@ elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc, strtab = (const char *) D_PTR (map,l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/sysdeps/sh/dl-machine.h b/libc/sysdeps/sh/dl-machine.h index 25cd52a8e..da7b9c1a0 100644 --- a/libc/sysdeps/sh/dl-machine.h +++ b/libc/sysdeps/sh/dl-machine.h @@ -336,8 +336,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc, strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/sysdeps/sh/sh4/fpu/libm-test-ulps b/libc/sysdeps/sh/sh4/fpu/libm-test-ulps index eb17664c1..d517ea9e2 100644 --- a/libc/sysdeps/sh/sh4/fpu/libm-test-ulps +++ b/libc/sysdeps/sh/sh4/fpu/libm-test-ulps @@ -1,764 +1,764 @@ # Begin of automatic generation # asin -Test "asin (-0.5) == -pi/6": +Test "asin (-0.5)": float: 2 ifloat: 2 -Test "asin (0.5) == pi/6": +Test "asin (0.5)": float: 2 ifloat: 2 -Test "asin (0.7) == 0.7753974966107530637": +Test "asin (0.7)": double: 1 float: 2 idouble: 1 ifloat: 2 # atan2 -Test "atan2 (-0.7, -1.0) == -2.530866689200584621918884506789267": +Test "atan2 (-0.7, -1.0)": float: 3 ifloat: 3 -Test "atan2 (0.7, -1.0) == 2.530866689200584621918884506789267": +Test "atan2 (0.7, -1.0)": float: 3 ifloat: 3 -Test "atan2 (1.4, -0.93) == 2.1571487668237843754887415992772736": +Test "atan2 (1.4, -0.93)": float: 4 ifloat: 4 # atanh -Test "atanh (0.7) == 0.8673005276940531944": +Test "atanh (0.7)": double: 1 idouble: 1 # cabs -Test "cabs (-0.7 + 12.4 i) == 12.419742348374220601176836866763271": +Test "cabs (-0.7 + 12.4 i)": float: 1 ifloat: 1 -Test "cabs (-0.7 - 12.4 i) == 12.419742348374220601176836866763271": +Test "cabs (-0.7 - 12.4 i)": float: 1 ifloat: 1 -Test "cabs (-12.4 + 0.7 i) == 12.419742348374220601176836866763271": +Test "cabs (-12.4 + 0.7 i)": float: 1 ifloat: 1 -Test "cabs (-12.4 - 0.7 i) == 12.419742348374220601176836866763271": +Test "cabs (-12.4 - 0.7 i)": float: 1 ifloat: 1 -Test "cabs (0.7 + 1.2 i) == 1.3892443989449804508432547041028554": +Test "cabs (0.7 + 1.2 i)": double: 1 idouble: 1 -Test "cabs (0.7 + 12.4 i) == 12.419742348374220601176836866763271": +Test "cabs (0.7 + 12.4 i)": float: 1 ifloat: 1 # cacos -Test "Real part of: cacos (0.7 + 1.2 i) == 1.1351827477151551088992008271819053 - 1.0927647857577371459105272080819308 i": +Test "Real part of: cacos (0.7 + 1.2 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.7 + 1.2 i) == 1.1351827477151551088992008271819053 - 1.0927647857577371459105272080819308 i": +Test "Imaginary part of: cacos (0.7 + 1.2 i)": float: 1 ifloat: 1 # cacosh -Test "Real part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Real part of: cacosh (-2 - 3 i)": double: 1 float: 7 idouble: 1 ifloat: 7 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": double: 1 float: 3 idouble: 1 ifloat: 3 -Test "Real part of: cacosh (0.7 + 1.2 i) == 1.0927647857577371459105272080819308 + 1.1351827477151551088992008271819053 i": +Test "Real part of: cacosh (0.7 + 1.2 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # casin -Test "Real part of: casin (0.7 + 1.2 i) == 0.4356135790797415103321208644578462 + 1.0927647857577371459105272080819308 i": +Test "Real part of: casin (0.7 + 1.2 i)": double: 3 float: 2 idouble: 3 ifloat: 2 -Test "Imaginary part of: casin (0.7 + 1.2 i) == 0.4356135790797415103321208644578462 + 1.0927647857577371459105272080819308 i": +Test "Imaginary part of: casin (0.7 + 1.2 i)": float: 1 ifloat: 1 # casinh -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 -Test "Real part of: casinh (0.7 + 1.2 i) == 0.97865459559367387689317593222160964 + 0.91135418953156011567903546856170941 i": +Test "Real part of: casinh (0.7 + 1.2 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0.7 + 1.2 i) == 0.97865459559367387689317593222160964 + 0.91135418953156011567903546856170941 i": +Test "Imaginary part of: casinh (0.7 + 1.2 i)": float: 1 ifloat: 1 # catan -Test "Real part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Real part of: catan (-2 - 3 i)": float: 3 ifloat: 3 -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: catan (0.7 + 1.2 i) == 1.0785743834118921877443707996386368 + 0.57705737765343067644394541889341712 i": +Test "Real part of: catan (0.7 + 1.2 i)": float: 4 ifloat: 4 -Test "Imaginary part of: catan (0.7 + 1.2 i) == 1.0785743834118921877443707996386368 + 0.57705737765343067644394541889341712 i": +Test "Imaginary part of: catan (0.7 + 1.2 i)": double: 1 idouble: 1 # catanh -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 -Test "Imaginary part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Imaginary part of: catanh (-2 - 3 i)": float: 4 ifloat: 4 -Test "Real part of: catanh (0.7 + 1.2 i) == 0.2600749516525135959200648705635915 + 0.97024030779509898497385130162655963 i": +Test "Real part of: catanh (0.7 + 1.2 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0.7 + 1.2 i) == 0.2600749516525135959200648705635915 + 0.97024030779509898497385130162655963 i": +Test "Imaginary part of: catanh (0.7 + 1.2 i)": double: 1 float: 6 idouble: 1 ifloat: 6 # cbrt -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.970299) == 0.99": +Test "cbrt (0.970299)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (0.7 + 1.2 i) == 1.3848657645312111080 - 0.97242170335830028619 i": +Test "Real part of: ccos (0.7 + 1.2 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.7 + 1.2 i) == 1.3848657645312111080 - 0.97242170335830028619 i": +Test "Imaginary part of: ccos (0.7 + 1.2 i)": double: 1 idouble: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (0.7 + 1.2 i) == 0.4548202223691477654 + 0.7070296600921537682 i": +Test "Real part of: ccosh (0.7 + 1.2 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.7 + 1.2 i) == 0.4548202223691477654 + 0.7070296600921537682 i": +Test "Imaginary part of: ccosh (0.7 + 1.2 i)": double: 1 idouble: 1 # cexp -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Real part of: cexp (0.7 + 1.2 i) == 0.7296989091503236012 + 1.8768962328348102821 i": +Test "Real part of: cexp (0.7 + 1.2 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cexp (0.7 + 1.2 i) == 0.7296989091503236012 + 1.8768962328348102821 i": +Test "Imaginary part of: cexp (0.7 + 1.2 i)": float: 1 ifloat: 1 # clog -Test "Imaginary part of: clog (-2 - 3 i) == 1.2824746787307683680267437207826593 - 2.1587989303424641704769327722648368 i": +Test "Imaginary part of: clog (-2 - 3 i)": double: 1 float: 3 idouble: 1 ifloat: 3 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 float: 5 idouble: 1 ifloat: 5 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0.7 + 1.2 i) == 0.1427786545038868803 + 0.4528483579352493248 i": +Test "Real part of: clog10 (0.7 + 1.2 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0.7 + 1.2 i) == 0.1427786545038868803 + 0.4528483579352493248 i": +Test "Imaginary part of: clog10 (0.7 + 1.2 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": float: 1 ifloat: 1 # cos -Test "cos (0.7) == 0.7648421872844884262": +Test "cos (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 float: 0.5 idouble: 1 ifloat: 0.5 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "cos (pi/2) == 0": +Test "cos (pi/2)": double: 0.2758 float: 0.3667 idouble: 0.2758 ifloat: 0.3667 # cpow -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 1.1031 float: 1.5 idouble: 1.1031 ifloat: 1.5 # csin -Test "Imaginary part of: csin (0.7 + 1.2 i) == 1.1664563419657581376 + 1.1544997246948547371 i": +Test "Imaginary part of: csin (0.7 + 1.2 i)": float: 1 ifloat: 1 # csinh -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Real part of: csinh (0.7 + 1.2 i) == 0.27487868678117583582 + 1.1698665727426565139 i": +Test "Real part of: csinh (0.7 + 1.2 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.7 + 1.2 i) == 0.27487868678117583582 + 1.1698665727426565139 i": +Test "Imaginary part of: csinh (0.7 + 1.2 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0.7 + 1.2 i) == 1.022067610030026450706487883081139 + 0.58704531296356521154977678719838035 i": +Test "Real part of: csqrt (0.7 + 1.2 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: csqrt (0.7 + 1.2 i) == 1.022067610030026450706487883081139 + 0.58704531296356521154977678719838035 i": +Test "Imaginary part of: csqrt (0.7 + 1.2 i)": float: 1 ifloat: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": double: 1 idouble: 1 -Test "Real part of: ctan (0.7 + 1.2 i) == 0.1720734197630349001 + 0.9544807059989405538 i": +Test "Real part of: ctan (0.7 + 1.2 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (0.7 + 1.2 i) == 0.1720734197630349001 + 0.9544807059989405538 i": +Test "Imaginary part of: ctan (0.7 + 1.2 i)": double: 1 float: 1 idouble: 1 ifloat: 1 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": float: 1 ifloat: 1 -Test "Real part of: ctanh (0.7 + 1.2 i) == 1.3472197399061191630 + 0.4778641038326365540 i": +Test "Real part of: ctanh (0.7 + 1.2 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: ctanh (0.7 + 1.2 i) == 1.3472197399061191630 + 0.4778641038326365540 i": +Test "Imaginary part of: ctanh (0.7 + 1.2 i)": double: 2 float: 1 idouble: 2 ifloat: 1 # erfc -Test "erfc (0.7) == 0.32219880616258152702": +Test "erfc (0.7)": double: 1 idouble: 1 -Test "erfc (1.2) == 0.089686021770364619762": +Test "erfc (1.2)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "erfc (2.0) == 0.0046777349810472658379": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.1) == 0.67000276540848983727e-8": +Test "erfc (4.1)": double: 24 float: 12 idouble: 24 ifloat: 12 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "exp10 (0.7) == 5.0118723362727228500": +Test "exp10 (0.7)": float: 1 ifloat: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 6 float: 2 idouble: 6 ifloat: 2 # expm1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": float: 1 ifloat: 1 # fmod -Test "fmod (-6.5, -2.3) == -1.9": +Test "fmod (-6.5, -2.3)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "fmod (-6.5, 2.3) == -1.9": +Test "fmod (-6.5, 2.3)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "fmod (6.5, -2.3) == 1.9": +Test "fmod (6.5, -2.3)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "fmod (6.5, 2.3) == 1.9": +Test "fmod (6.5, 2.3)": double: 2 float: 1 idouble: 2 ifloat: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 1.2) == 1.3892443989449804508432547041028554": +Test "hypot (0.7, 1.2)": double: 1 idouble: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (10.0) == -0.24593576445134833520": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "j0 (2.0) == 0.22389077914123566805": +Test "j0 (2.0)": float: 2 ifloat: 2 -Test "j0 (8.0) == 0.17165080713755390609": +Test "j0 (8.0)": float: 1 ifloat: 1 # j1 -Test "j1 (10.0) == 0.043472746168861436670": +Test "j1 (10.0)": float: 2 ifloat: 2 -Test "j1 (2.0) == 0.57672480775687338720": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.23463634685391462438": +Test "j1 (8.0)": double: 1 idouble: 1 # jn -Test "jn (0, 10.0) == -0.24593576445134833520": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (0, 2.0) == 0.22389077914123566805": +Test "jn (0, 2.0)": float: 2 ifloat: 2 -Test "jn (0, 8.0) == 0.17165080713755390609": +Test "jn (0, 8.0)": float: 1 ifloat: 1 -Test "jn (1, 10.0) == 0.043472746168861436670": +Test "jn (1, 10.0)": float: 2 ifloat: 2 -Test "jn (1, 2.0) == 0.57672480775687338720": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.23463634685391462438": +Test "jn (1, 8.0)": double: 1 idouble: 1 -Test "jn (10, 0.1) == 0.26905328954342155795e-19": +Test "jn (10, 0.1)": double: 6 float: 4 idouble: 6 ifloat: 4 -Test "jn (10, 0.7) == 0.75175911502153953928e-11": +Test "jn (10, 0.7)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (10, 10.0) == 0.20748610663335885770": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 -Test "jn (10, 2.0) == 0.25153862827167367096e-6": +Test "jn (10, 2.0)": float: 4 ifloat: 4 -Test "jn (3, 0.1) == 0.000020820315754756261429": +Test "jn (3, 0.1)": double: 1 idouble: 1 -Test "jn (3, 0.7) == 0.0069296548267508408077": +Test "jn (3, 0.7)": float: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.058379379305186812343": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "jn (3, 2.0) == 0.12894324947440205110": +Test "jn (3, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 # lgamma -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 ifloat: 2 # log -Test "log (0.7) == -0.35667494393873237891263871124118447": +Test "log (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # log10 -Test "log10 (0.7) == -0.15490195998574316929": +Test "log10 (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 # log1p -Test "log1p (-0.3) == -0.35667494393873237891263871124118447": +Test "log1p (-0.3)": double: 1 float: 1 idouble: 1 ifloat: 1 # log2 -Test "log2 (0.7) == -0.51457317282975824043": +Test "log2 (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # sincos -Test "sincos (0.7, &sin_res, &cos_res) puts 0.76484218728448842626 in cos_res": +Test "sincos (0.7) extra output 2": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -float: 0.5 -idouble: 1 -ifloat: 0.5 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.866025403784438646764 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/2, &sin_res, &cos_res) puts 0 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +float: 0.5 +idouble: 1 +ifloat: 0.5 +Test "sincos (pi/2) extra output 2": double: 0.2758 float: 0.3667 idouble: 0.2758 ifloat: 0.3667 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.866025403784438646764 in cos_res": +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh -Test "sinh (0.7) == 0.75858370183953350346": +Test "sinh (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # tan -Test "tan (pi/4) == 1": +Test "tan (pi/4)": double: 0.5 idouble: 0.5 # tanh -Test "tanh (0.7) == 0.60436777711716349631": +Test "tanh (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 # y0 -Test "y0 (0.7) == -0.19066492933739506743": +Test "y0 (0.7)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.0) == 0.088256964215676957983": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.38244892379775884396": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.055671167283599391424": +Test "y0 (10.0)": float: 1 ifloat: 1 -Test "y0 (8.0) == 0.22352148938756622053": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 # y1 -Test "y1 (0.1) == -6.4589510947020269877": +Test "y1 (0.1)": double: 1 idouble: 1 -Test "y1 (0.7) == -1.1032498719076333697": +Test "y1 (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y1 (1.5) == -0.41230862697391129595": +Test "y1 (1.5)": float: 1 ifloat: 1 -Test "y1 (10.0) == 0.24901542420695388392": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.10703243154093754689": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y1 (8.0) == -0.15806046173124749426": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 # yn -Test "yn (0, 0.7) == -0.19066492933739506743": +Test "yn (0, 0.7)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.0) == 0.088256964215676957983": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.38244892379775884396": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.055671167283599391424": +Test "yn (0, 10.0)": float: 1 ifloat: 1 -Test "yn (0, 8.0) == 0.22352148938756622053": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 0.1) == -6.4589510947020269877": +Test "yn (1, 0.1)": double: 1 idouble: 1 -Test "yn (1, 0.7) == -1.1032498719076333697": +Test "yn (1, 0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 1.5) == -0.41230862697391129595": +Test "yn (1, 1.5)": float: 1 ifloat: 1 -Test "yn (1, 10.0) == 0.24901542420695388392": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.10703243154093754689": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (1, 8.0) == -0.15806046173124749426": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "yn (10, 0.1) == -0.11831335132045197885e19": +Test "yn (10, 0.1)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "yn (10, 0.7) == -0.42447194260703866924e10": +Test "yn (10, 0.7)": double: 3 idouble: 3 -Test "yn (10, 1.0) == -0.12161801427868918929e9": +Test "yn (10, 1.0)": double: 1 idouble: 1 -Test "yn (10, 10.0) == -0.35981415218340272205": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 2.0) == -129184.54220803928264": +Test "yn (10, 2.0)": double: 2 idouble: 2 -Test "yn (3, 0.1) == -5099.3323786129048894": +Test "yn (3, 0.1)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 0.7) == -15.819479052819633505": +Test "yn (3, 0.7)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (3, 10.0) == -0.25136265718383732978": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 2.0) == -1.1277837768404277861": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/sysdeps/sparc/fpu/libm-test-ulps b/libc/sysdeps/sparc/fpu/libm-test-ulps index ad7afc899..2226b4487 100644 --- a/libc/sysdeps/sparc/fpu/libm-test-ulps +++ b/libc/sysdeps/sparc/fpu/libm-test-ulps @@ -1,19 +1,19 @@ # Begin of automatic generation # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 @@ -22,19 +22,19 @@ ildouble: 1 ldouble: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 @@ -43,1471 +43,1471 @@ ildouble: 1 ldouble: 1 # acos_upward -Test "acos_upward (-0) == pi/2": +Test "acos_upward (-0)": ildouble: 1 ldouble: 1 -Test "acos_upward (-1) == pi": +Test "acos_upward (-1)": ildouble: 1 ldouble: 1 -Test "acos_upward (0) == pi/2": +Test "acos_upward (0)": ildouble: 1 ldouble: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (-1.0) == -pi/2": +Test "asin_downward (-1.0)": ildouble: 1 ldouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 # asin_upward -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 -Test "asin_upward (1.0) == pi/2": +Test "asin_upward (1.0)": ildouble: 1 ldouble: 1 # atan2 -Test "atan2 (-0.00756827042671106339, -.001792735857538728036) == -1.80338464113663849327153994379639112": +Test "atan2 (-0.00756827042671106339, -.001792735857538728036)": ildouble: 1 ldouble: 1 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x1.0000000000000002p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x1.0000000000001p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x1.0000000000000002p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x1.0000000000001p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (-0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (-0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + +0 i) == 2.094395102393195492308428922186335256131 - 0 i": +Test "Real part of: cacos (-0.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 0x1.fp-1025 i) == 2.094395102393195492308428922186335256131 - 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 - 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 + 0x1.fp-16385 i) == 2.094395102393195492308428922186335256131 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Real part of: cacos (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 0x1p-105 i) == 2.094395102393195492308428922186335256131 - 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (-0.5 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-105 i) == 2.094395102393195492308428922186335256131 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 0x1p-112 i) == 2.094395102393195492308428922186335256131 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (-0.5 + 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-112 i) == 2.094395102393195492308428922186335256131 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i) == 2.094395102393190022547898764614298351924 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 0x1p-52 i) == 2.094395102393195492308428922186316279087 - 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (-0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 0x1p-63 i) == 2.094395102393195492308428922186335256127 - 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (-0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-63 i) == 2.094395102393195492308428922186335256127 - 1.251928832280966098829878787499365228659e-19 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0 i) == 2.094395102393195492308428922186335256131 + +0 i": +Test "Real part of: cacos (-0.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0x1.fp-1025 i) == 2.094395102393195492308428922186335256131 + 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 + 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0.5 - 0x1.fp-16385 i) == 2.094395102393195492308428922186335256131 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Real part of: cacos (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0x1p-105 i) == 2.094395102393195492308428922186335256131 + 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (-0.5 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-105 i) == 2.094395102393195492308428922186335256131 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0x1p-112 i) == 2.094395102393195492308428922186335256131 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (-0.5 - 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-112 i) == 2.094395102393195492308428922186335256131 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i) == 2.094395102393190022547898764614298351924 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0x1p-52 i) == 2.094395102393195492308428922186316279087 + 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (-0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 0x1p-63 i) == 2.094395102393195492308428922186335256127 + 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (-0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-63 i) == 2.094395102393195492308428922186335256127 + 1.251928832280966098829878787499365228659e-19 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 3.141592634635223399311902261000251614142 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 3.141592634635223399311902261000251614142 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == 3.141592653589793038743797483317667178134 - 1.234330349600789959989661887846005659983e-16 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == 3.141592653589793038743797483317667178134 + 1.234330349600789959989661887846005659983e-16 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == 3.141592653170952461345846619605307690007 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == 3.141592653170952461345846619605307690007 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i) == 3.141153467203602189751698864505105063797 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i) == 3.141153467203602189751698864505105063797 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 + 0.0 i) == 3.141592653589793238462643383279502884197 - 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i) == 3.141592653589793238462643383279502884197 - 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 + 0x1p-113 i) == 3.141592653589793233694780199536825402504 - 2.019699255375255198156433710951064632386e-17 i": +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 - 0.0 i) == 3.141592653589793238462643383279502884197 + 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i) == 3.141592653589793238462643383279502884197 + 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 - 0x1p-113 i) == 3.141592653589793233694780199536825402504 + 2.019699255375255198156433710951064632386e-17 i": +Test "Imaginary part of: cacos (-0x1.0000000000000000000000000001p0 - 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.000002p0 + 0x1p-23 i) == 3.141370441751352383825802745874586120521 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.000002p0 - 0x1p-23 i) == 3.141370441751352383825802745874586120521 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i) == 1.572134236154454360143880041170803681211 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i) == 1.572134236154454360143880041170803681211 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691640832196834 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-100 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691640832196834 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691640832196834 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-100 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691640832196834 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 0.5 i) == 1.570796326794896619231321691639751442099 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 0x1.0000000000001p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 0.5 i) == 1.570796326794896619231321691639751442099 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 0x1.0000000000001p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442101 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442101 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x0.ffffffp0 i) == 1.570796326794896619231321691639751442101 - 8.813735448726938863015878255140556727969e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 - 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1.fp-129 i) == 1.570796326794896619231321691639751442101 - 2.846900380897727558361783801085126250967e-39 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1p-23 i) == 1.570796326794896619231321691639751442101 - 1.192092895507809676556842485683592032154e-7 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442101 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442101 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1.fp-129 + 1.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442101 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442101 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x0.ffffffp0 i) == 1.570796326794896619231321691639751442101 + 8.813735448726938863015878255140556727969e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 + 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1.fp-129 i) == 1.570796326794896619231321691639751442101 + 2.846900380897727558361783801085126250967e-39 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1p-23 i) == 1.570796326794896619231321691639751442101 + 1.192092895507809676556842485683592032154e-7 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442101 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442101 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1.fp-129 - 1.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 + 0.5 i) == 1.570796326794896619231321691639751442099 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x1.0000000000000002p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 - 0.5 i) == 1.570796326794896619231321691639751442099 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x1.0000000000000002p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-30 + 1.0 i) == 1.570796328070826603447840231892468927106 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: cacos (-0x1.fp-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i) == 1.570796328070826603447840231892468927106 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-30 - 1.0 i) == 1.570796328070826603447840231892468927106 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: cacos (-0x1.fp-30 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i) == 1.570796328070826603447840231892468927106 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-105 + 0.0 i) == 1.570796326794896619231321691639776094002 - 0.0 i": +Test "Real part of: cacos (-0x1p-105 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 + 0.5 i) == 1.570796326794896619231321691639773491431 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i) == 1.570796326794896619231321691639773491431 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639768873627 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-105 + 0x1p-105 i) == 1.570796326794896619231321691639776094002 - 2.465190328815661891911651766508706967729e-32 i": +Test "Real part of: cacos (-0x1p-105 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 - 0.0 i) == 1.570796326794896619231321691639776094002 + 0.0 i": +Test "Real part of: cacos (-0x1p-105 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 - 0.5 i) == 1.570796326794896619231321691639773491431 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i) == 1.570796326794896619231321691639773491431 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639768873627 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-105 - 0x1p-105 i) == 1.570796326794896619231321691639776094002 + 2.465190328815661891911651766508706967729e-32 i": +Test "Real part of: cacos (-0x1p-105 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0.0 i) == 1.570796326794896619231321691639751634692 - 0.0 i": +Test "Real part of: cacos (-0x1p-112 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751614359 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751614359 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0x1p-112 i) == 1.570796326794896619231321691639751634692 - 1.925929944387235853055977942584927318538e-34 i": +Test "Real part of: cacos (-0x1p-112 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0.0 i) == 1.570796326794896619231321691639751634692 + 0.0 i": +Test "Real part of: cacos (-0x1p-112 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751614359 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751614359 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0x1p-112 i) == 1.570796326794896619231321691639751634692 + 1.925929944387235853055977942584927318538e-34 i": +Test "Real part of: cacos (-0x1p-112 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-113 + 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751510190 - 8.813735870195430252326093249797924452120e-1 i": +Test "Real part of: cacos (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-113 + 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751510190 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-113 - 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751510190 + 8.813735870195430252326093249797924452120e-1 i": +Test "Real part of: cacos (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-113 - 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751510190 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-23 + 0.0 i) == 1.570796446004186170012854035955502877351 - 0.0 i": +Test "Real part of: cacos (-0x1p-23 + 0.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-23 + 0.5 i) == 1.570796433418926613232299739606181733819 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: cacos (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i) == 1.570796433418926613232299739606181733819 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1p-23 + 0x1.fp-129 i) == 1.570796446004186170012854035955502877351 - 2.846900380897747786805634596726756660388e-39 i": +Test "Real part of: cacos (-0x1p-23 + 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-23 + 0x1p-23 i) == 1.570796446004186170012007003008248567984 - 1.192092895507818146886315028596704749235e-7 i": +Test "Real part of: cacos (-0x1p-23 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-23 - 0.0 i) == 1.570796446004186170012854035955502877351 + 0.0 i": +Test "Real part of: cacos (-0x1p-23 - 0.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-23 - 0.5 i) == 1.570796433418926613232299739606181733819 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: cacos (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i) == 1.570796433418926613232299739606181733819 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1p-23 - 0x1.fp-129 i) == 1.570796446004186170012854035955502877351 + 2.846900380897747786805634596726756660388e-39 i": +Test "Real part of: cacos (-0x1p-23 - 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-23 - 0x1p-23 i) == 1.570796446004186170012007003008248567984 + 1.192092895507818146886315028596704749235e-7 i": +Test "Real part of: cacos (-0x1p-23 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-52 + 0.0 i) == 1.570796326794896841275926616671059526825 - 0.0 i": +Test "Real part of: cacos (-0x1p-52 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 + 0.5 i) == 1.570796326794896817834053951421591208280 - 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: cacos (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i) == 1.570796326794896817834053951421591208280 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-52 + 0x1p-52 i) == 1.570796326794896841275926616671059526825 - 2.220446049250313080847263336181677117148e-16 i": +Test "Real part of: cacos (-0x1p-52 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 - 0.0 i) == 1.570796326794896841275926616671059526825 + 0.0 i": +Test "Real part of: cacos (-0x1p-52 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 - 0.5 i) == 1.570796326794896817834053951421591208280 + 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: cacos (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i) == 1.570796326794896817834053951421591208280 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-52 - 0x1p-52 i) == 1.570796326794896841275926616671059526825 + 2.220446049250313080847263336181677117148e-16 i": +Test "Real part of: cacos (-0x1p-52 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 + 0.0 i) == 1.570796326794896619339741908888301885499 - 0.0 i": +Test "Real part of: cacos (-0x1p-63 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 + 0.5 i) == 1.570796326794896619328295682000973043547 - 4.812118250596034474977589134243684231373e-1 i": +Test "Real part of: cacos (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i) == 1.570796326794896619328295682000973043547 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619307986362473920146173 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0x1.0000000000000002p0 i) == 1.570796326794896619307986362473920146166 - 8.813735870195430253092739958139610131001e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-63 + 0x1p-63 i) == 1.570796326794896619339741908888301885499 - 1.084202172485504434007452800869941711430e-19 i": +Test "Real part of: cacos (-0x1p-63 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 - 0.0 i) == 1.570796326794896619339741908888301885499 + 0.0 i": +Test "Real part of: cacos (-0x1p-63 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 - 0.5 i) == 1.570796326794896619328295682000973043547 + 4.812118250596034474977589134243684231373e-1 i": +Test "Real part of: cacos (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i) == 1.570796326794896619328295682000973043547 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619307986362473920146173 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0x1.0000000000000002p0 i) == 1.570796326794896619307986362473920146166 + 8.813735870195430253092739958139610131001e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-63 - 0x1p-63 i) == 1.570796326794896619339741908888301885499 + 1.084202172485504434007452800869941711430e-19 i": +Test "Real part of: cacos (-0x1p-63 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p500 + 1.0 i) == 3.141592653589793238462643383279502884197 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (-0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p500 - 1.0 i) == 3.141592653589793238462643383279502884197 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (-0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p5000 + 1.0 i) == 3.141592653589793238462643383279502884197 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (-0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p5000 - 1.0 i) == 3.141592653589793238462643383279502884197 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (-0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 + 0.5 i) == 2.466703808003786858297978415967328452322 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1.fp-30 i) == 3.141550174918818561961484385371624132331 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 + 0x1p50 i) == 1.570796326794897507409741391764983781004 - 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-1.0 + 0x1p50 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1p500 i) == 1.570796326794896619231321691639751442099 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (-1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1p5000 i) == 1.570796326794896619231321691639751442099 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (-1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 - 0.5 i) == 2.466703808003786858297978415967328452322 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1.fp-30 i) == 3.141550174918818561961484385371624132331 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 - 0x1p50 i) == 1.570796326794897507409741391764983781004 + 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-1.0 - 0x1p50 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1p500 i) == 1.570796326794896619231321691639751442099 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (-1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1p5000 i) == 1.570796326794896619231321691639751442099 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (-1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-2 - 3 i) == 2.1414491111159960199416055713254211 + 1.9833870299165354323470769028940395 i": +Test "Real part of: cacos (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x1.0000000000000002p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x1.0000000000001p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x1.0000000000000002p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x1.0000000000001p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.25 + 1.0 i) == 1.394493894017929688812643125003661339452 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.25 - 1.0 i) == 1.394493894017929688812643125003661339452 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 - 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-105 i) == 1.047197551196597746154214461093167628066 - 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-105 i) == 1.047197551196597746154214461093167628066 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-112 i) == 1.047197551196597746154214461093167628066 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-112 i) == 1.047197551196597746154214461093167628066 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-23 i) == 1.047197551196603215914744618665204532273 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-52 i) == 1.047197551196597746154214461093186605110 - 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-63 i) == 1.047197551196597746154214461093167628070 - 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 + 0x1p-63 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-63 i) == 1.047197551196597746154214461093167628070 - 1.251928832280966098829878787499365228659e-19 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 1.0 i) == 1.221357263937683325603909865564381489366 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.5 + 1.0 i) == 1.221357263937683325603909865564381489366 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 + 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-105 i) == 1.047197551196597746154214461093167628066 + 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-105 i) == 1.047197551196597746154214461093167628066 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-112 i) == 1.047197551196597746154214461093167628066 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-112 i) == 1.047197551196597746154214461093167628066 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-23 i) == 1.047197551196603215914744618665204532273 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-52 i) == 1.047197551196597746154214461093186605110 + 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-63 i) == 1.047197551196597746154214461093167628070 + 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 - 0x1p-63 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-63 i) == 1.047197551196597746154214461093167628070 + 1.251928832280966098829878787499365228659e-19 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 1.0 i) == 1.221357263937683325603909865564381489366 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.5 - 1.0 i) == 1.221357263937683325603909865564381489366 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Real part of: cacos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: cacos (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i) == 1.570092458683775059393382371963565104164e-16 - 0.0 i": +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i) == 1.570092458683775059393382371963565104164e-16 - 3.432186888910770473784103112009399360940e-293 i": +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == 1.997188458999618357060632049675702684031e-16 - 1.234330349600789959989661887846005659983e-16 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i) == 1.570092458683775059393382371963565104164e-16 + 0.0 i": +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i) == 1.570092458683775059393382371963565104164e-16 + 3.432186888910770473784103112009399360940e-293 i": +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == 1.997188458999618357060632049675702684031e-16 + 1.234330349600789959989661887846005659983e-16 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 + 0.0 i) == 1.387778780781445675529539585113525401762e-17 - 0.0 i": +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 + 0x1.fp-16385 i) == 1.387778780781445675529539585113525401762e-17 - 5.867357004219059108790368268900490184505e-4916 i": +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 - 0.0 i) == 1.387778780781445675529539585113525401762e-17 + 0.0 i": +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 - 0x1.fp-16385 i) == 1.387778780781445675529539585113525401762e-17 + 5.867357004219059108790368268900490184505e-4916 i": +Test "Real part of: cacos (0x0.ffffffffffffffffffffffffffff8p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i) == 3.452669847162035876032494826387364972849e-4 - 0.0 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i) == 3.452669847162035876032494826387364972849e-4 - 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i) == 3.452669847162035876032494826387364972849e-4 + 0.0 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i) == 3.452669847162035876032494826387364972849e-4 + 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 + 0.0 i) == 0.0 - 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i) == 4.148847925325683229178506116378864361396e-4916 - 1.962615573354718824241727964954454332780e-17 i": +Test "Real part of: cacos (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i) == 4.148847925325683229178506116378864361396e-4916 - 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 + 0x1p-113 i) == 4.767863183742677481693563511435642755521e-18 - 2.019699255375255198156433710951064632386e-17 i": +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 - 0.0 i) == 0.0 + 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i) == 4.148847925325683229178506116378864361396e-4916 + 1.962615573354718824241727964954454332780e-17 i": +Test "Real part of: cacos (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i) == 4.148847925325683229178506116378864361396e-4916 + 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 - 0x1p-113 i) == 4.767863183742677481693563511435642755521e-18 + 2.019699255375255198156433710951064632386e-17 i": +Test "Imaginary part of: cacos (0x1.0000000000000000000000000001p0 - 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 - 5.116146586219826555037807251857670783420e-10 i": +Test "Real part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 + 5.116146586219826555037807251857670783420e-10 i": +Test "Real part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 - 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 + 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 - 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.000002p0 + 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 + 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.000002p0 - 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i) == 1.569458417435338878318763342108699202986 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i) == 1.569458417435338878318763342108699202986 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691638670687364 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (0x1.fp-100 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691638670687364 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691638670687364 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (0x1.fp-100 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691638670687364 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 0.5 i) == 1.570796326794896619231321691639751442099 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 0x1.0000000000001p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 0.5 i) == 1.570796326794896619231321691639751442099 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 0x1.0000000000001p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442096 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442097 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442097 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442096 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442097 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442097 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 + 0.5 i) == 1.570796326794896619231321691639751442099 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 + 0x1.0000000000000002p0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 - 0.5 i) == 1.570796326794896619231321691639751442099 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 - 0x1.0000000000000002p0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i) == 1.570796325518966635014803151387033957091 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i) == 1.570796325518966635014803151387033957091 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 - 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 - 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp16383 + 0x1.fp16383 i) == 7.853981633974483096156608458198757210493e-1 - 1.135753137836666928715489992987020363057e4 i": +Test "Imaginary part of: cacos (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-105 + 0.5 i) == 1.570796326794896619231321691639729392766 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639734010571 - 8.813735870195430252326093249797835932642e-1 i": +Test "Real part of: cacos (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639734010571 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-105 - 0.5 i) == 1.570796326794896619231321691639729392766 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639734010571 + 8.813735870195430252326093249797835932642e-1 i": +Test "Real part of: cacos (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.570796326794896619231321691639734010571 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: cacos (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751269838 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i) == 1.570796326794896619231321691639751305915 - 8.813735870195430252326093249797922409363e-1 i": +Test "Real part of: cacos (0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751269838 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i) == 1.570796326794896619231321691639751305915 + 8.813735870195430252326093249797922409363e-1 i": +Test "Real part of: cacos (0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-113 + 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751374007 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-113 - 0x1.0000000000000000000000000001p0 i) == 1.570796326794896619231321691639751374007 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: cacos (0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0.5 i) == 1.570796220170866625230343643673321150378 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x1p-23 + 0x1.000002p0 i) == 1.570796242501204621739026081991856762292 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: cacos (0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0.5 i) == 1.570796220170866625230343643673321150378 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0x1p-23 - 0x1.000002p0 i) == 1.570796242501204621739026081991856762292 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: cacos (0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-52 + 0.5 i) == 1.570796326794896420628589431857911675917 - 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: cacos (0x1p-52 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 + 0.5 i) == 1.570796326794896420628589431857911675917 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.570796326794896462222075823262236786996 - 8.813735870195429467279863907910458761820e-1 i": +Test "Real part of: cacos (0x1p-52 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-52 - 0.5 i) == 1.570796326794896420628589431857911675917 + 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: cacos (0x1p-52 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 - 0.5 i) == 1.570796326794896420628589431857911675917 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.570796326794896462222075823262236786996 + 8.813735870195429467279863907910458761820e-1 i": +Test "Real part of: cacos (0x1p-52 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-63 + 0.5 i) == 1.570796326794896619134347701278529840650 - 4.812118250596034474977589134243684231373e-1 i": +Test "Real part of: cacos (0x1p-63 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0.5 i) == 1.570796326794896619134347701278529840650 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619154657020805582738025 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0x1.0000000000000002p0 i) == 1.570796326794896619154657020805582738031 - 8.813735870195430253092739958139610131001e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1p-63 - 0.5 i) == 1.570796326794896619134347701278529840650 + 4.812118250596034474977589134243684231373e-1 i": +Test "Real part of: cacos (0x1p-63 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0.5 i) == 1.570796326794896619134347701278529840650 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619154657020805582738025 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0x1.0000000000000002p0 i) == 1.570796326794896619154657020805582738031 + 8.813735870195430253092739958139610131001e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p500 + 1.0 i) == 3.054936363499604682051979393213617699789e-151 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p500 - 1.0 i) == 3.054936363499604682051979393213617699789e-151 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p5000 + 1.0 i) == 7.079811261048172892385615158694057552948e-1506 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p5000 - 1.0 i) == 7.079811261048172892385615158694057552948e-1506 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0.25 i) == 4.890443302710802929202843732146540079124e-1 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: cacos (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 + 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0x1.fp-100 i) == 1.236292038260260888664514866456887257525e-15 - 1.236292038260260888664514866457202186027e-15 i": +Test "Real part of: cacos (1.0 + 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 + 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 + 0x1p500 i) == 1.570796326794896619231321691639751442099 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 + 0x1p5000 i) == 1.570796326794896619231321691639751442099 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0.25 i) == 4.890443302710802929202843732146540079124e-1 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: cacos (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 - 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0x1.fp-100 i) == 1.236292038260260888664514866456887257525e-15 + 1.236292038260260888664514866457202186027e-15 i": +Test "Real part of: cacos (1.0 - 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 - 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 - 0x1p500 i) == 1.570796326794896619231321691639751442099 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: cacos (1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 - 0x1p5000 i) == 1.570796326794896619231321691639751442099 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: cacos (1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": double: 1 float: 1 idouble: 1 @@ -1516,2637 +1516,2637 @@ ildouble: 1 ldouble: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610130980e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x1.0000000000001p0 i) == 8.813735870195431822418551933572895326024e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610130980e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x1.0000000000001p0 i) == 8.813735870195431822418551933572895326024e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Real part of: cacosh (-0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Real part of: cacosh (-0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0.5 + +0 i) == +0 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 2.094395102393195492308428922186316279087 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 + 2.094395102393195492308428922186335256127 i": +Test "Real part of: cacosh (-0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 + 2.094395102393195492308428922186335256127 i": +Test "Imaginary part of: cacosh (-0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Imaginary part of: cacosh (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0.5 - 0 i) == +0 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 2.094395102393195492308428922186335256131 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 2.094395102393195492308428922186316279087 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 - 2.094395102393195492308428922186335256127 i": +Test "Real part of: cacosh (-0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 - 2.094395102393195492308428922186335256127 i": +Test "Imaginary part of: cacosh (-0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Imaginary part of: cacosh (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == 1.234330349600789959989661887846005659983e-16 + 3.141592653589793038743797483317667178134 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == 1.234330349600789959989661887846005659983e-16 - 3.141592653589793038743797483317667178134 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 3.141592653170952461345846619605307690007 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 3.141592653170952461345846619605307690007 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 + 0.0 i) == 1.962615573354718824241727964954454332780e-17 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i) == 1.962615573354718824241727964954454332780e-17 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 + 0x1p-113 i) == 2.019699255375255198156433710951064632386e-17 + 3.141592653589793233694780199536825402504 i": +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 - 0.0 i) == 1.962615573354718824241727964954454332780e-17 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i) == 1.962615573354718824241727964954454332780e-17 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 - 0x1p-113 i) == 2.019699255375255198156433710951064632386e-17 - 3.141592653589793233694780199536825402504 i": +Test "Real part of: cacosh (-0x1.0000000000000000000000000001p0 - 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 3.141370441751352383825802745874586120521 i": +Test "Real part of: cacosh (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 3.141370441751352383825802745874586120521 i": +Test "Real part of: cacosh (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691640832196834 i": +Test "Imaginary part of: cacosh (-0x1.fp-100 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691640832196834 i": +Test "Imaginary part of: cacosh (-0x1.fp-100 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-10000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-10000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-10000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 0x1.0000000000001p0 i) == 8.813735870195431822418551933572895326024e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 0x1.0000000000001p0 i) == 8.813735870195431822418551933572895326024e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x0.ffffffp0 i) == 8.813735448726938863015878255140556727969e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.fp-129 i) == 2.846900380897727558361783801085126250967e-39 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442100 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x0.ffffffp0 i) == 8.813735448726938863015878255140556727969e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.fp-129 i) == 2.846900380897727558361783801085126250967e-39 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442100 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-16385 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 + 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610130980e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 - 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610130980e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796328070826603447840231892468927106 i": +Test "Imaginary part of: cacosh (-0x1.fp-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796328070826603447840231892468927106 i": +Test "Imaginary part of: cacosh (-0x1.fp-30 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0.0 i) == 0.0 + 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639773491431 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 + 1.570796326794896619231321691639768873627 i": +Test "Real part of: cacosh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0x1p-105 i) == 2.465190328815661891911651766508706967729e-32 + 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0.0 i) == 0.0 - 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639773491431 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 - 1.570796326794896619231321691639768873627 i": +Test "Real part of: cacosh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0x1p-105 i) == 2.465190328815661891911651766508706967729e-32 - 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0.0 i) == 0.0 + 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751614359 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0x1p-112 i) == 1.925929944387235853055977942584927318538e-34 + 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0.0 i) == 0.0 - 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751614359 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0x1p-112 i) == 1.925929944387235853055977942584927318538e-34 - 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-113 + 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 + 1.570796326794896619231321691639751510190 i": +Test "Real part of: cacosh (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-113 + 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 + 1.570796326794896619231321691639751510190 i": +Test "Imaginary part of: cacosh (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-113 - 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 - 1.570796326794896619231321691639751510190 i": +Test "Real part of: cacosh (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-113 - 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 - 1.570796326794896619231321691639751510190 i": +Test "Imaginary part of: cacosh (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0.0 i) == 0.0 + 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (-0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796433418926613232299739606181733819 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0x1.fp-129 i) == 2.846900380897747786805634596726756660388e-39 + 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0x1p-23 i) == 1.192092895507818146886315028596704749235e-7 + 1.570796446004186170012007003008248567984 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0.0 i) == 0.0 - 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (-0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796433418926613232299739606181733819 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0x1.fp-129 i) == 2.846900380897747786805634596726756660388e-39 - 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0x1p-23 i) == 1.192092895507818146886315028596704749235e-7 - 1.570796446004186170012007003008248567984 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0.0 i) == 0.0 + 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896817834053951421591208280 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0x1p-52 i) == 2.220446049250313080847263336181677117148e-16 + 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0.0 i) == 0.0 - 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896817834053951421591208280 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0x1p-52 i) == 2.220446049250313080847263336181677117148e-16 - 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0.0 i) == 0.0 + 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619328295682000973043547 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 + 1.570796326794896619307986362473920146173 i": +Test "Real part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-63 + 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610131001e-1 + 1.570796326794896619307986362473920146166 i": +Test "Real part of: cacosh (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0x1p-63 i) == 1.084202172485504434007452800869941711430e-19 + 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0.0 i) == 0.0 - 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619328295682000973043547 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 - 1.570796326794896619307986362473920146173 i": +Test "Real part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-63 - 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610131001e-1 - 1.570796326794896619307986362473920146166 i": +Test "Real part of: cacosh (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0x1p-63 i) == 1.084202172485504434007452800869941711430e-19 - 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p500 + 1.0 i) == 3.472667374605326000180332928505464606058e2 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p500 - 1.0 i) == 3.472667374605326000180332928505464606058e2 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p5000 + 1.0 i) == 3.466429049980286492395577839412341016946e3 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p5000 - 1.0 i) == 3.466429049980286492395577839412341016946e3 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 3.098101355958774410750062883737683164607 i": +Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 + 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 + 3.141550174918818561961484385371624132331 i": +Test "Real part of: cacosh (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 + 0x1p50 i) == 3.535050620855721078027883819436759661753e1 + 1.570796326794897507409741391764983781004 i": +Test "Imaginary part of: cacosh (-1.0 + 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 + 0x1p500 i) == 3.472667374605326000180332928505464606058e2 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 + 0x1p5000 i) == 3.466429049980286492395577839412341016946e3 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 3.098101355958774410750062883737683164607 i": +Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 - 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 - 3.141550174918818561961484385371624132331 i": +Test "Real part of: cacosh (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 - 0x1p50 i) == 3.535050620855721078027883819436759661753e1 - 1.570796326794897507409741391764983781004 i": +Test "Imaginary part of: cacosh (-1.0 - 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 - 0x1p500 i) == 3.472667374605326000180332928505464606058e2 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 - 0x1p5000 i) == 3.466429049980286492395577839412341016946e3 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610130980e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x1.0000000000001p0 i) == 8.813735870195431822418551933572895326024e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610130980e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x1.0000000000001p0 i) == 8.813735870195431822418551933572895326024e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.394493894017929688812643125003661339452 i": +Test "Real part of: cacosh (0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.394493894017929688812643125003661339452 i": +Test "Real part of: cacosh (0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + +0 i) == +0 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + +0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 1.047197551196597746154214461093186605110 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 + 1.047197551196597746154214461093167628070 i": +Test "Real part of: cacosh (0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 + 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.221357263937683325603909865564381489366 i": +Test "Imaginary part of: cacosh (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0.5 - 0 i) == +0 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 1.047197551196597746154214461093186605110 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 - 1.047197551196597746154214461093167628070 i": +Test "Real part of: cacosh (0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 - 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.221357263937683325603909865564381489366 i": +Test "Imaginary part of: cacosh (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i) == 0.0 + 1.570092458683775059393382371963565104164e-16 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i) == 3.432186888910770473784103112009399360940e-293 + 1.570092458683775059393382371963565104164e-16 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == 1.234330349600789959989661887846005659983e-16 + 1.997188458999618357060632049675702684031e-16 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i) == 0.0 - 1.570092458683775059393382371963565104164e-16 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i) == 3.432186888910770473784103112009399360940e-293 - 1.570092458683775059393382371963565104164e-16 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == 1.234330349600789959989661887846005659983e-16 - 1.997188458999618357060632049675702684031e-16 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 + 0.0 i) == 0.0 + 1.387778780781445675529539585113525401762e-17 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 + 0x1.fp-16385 i) == 5.867357004219059108790368268900490184505e-4916 + 1.387778780781445675529539585113525401762e-17 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 - 0.0 i) == 0.0 - 1.387778780781445675529539585113525401762e-17 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 - 0x1.fp-16385 i) == 5.867357004219059108790368268900490184505e-4916 - 1.387778780781445675529539585113525401762e-17 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffffffffffffff8p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 4.188407771167967636741951941902992986043e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 4.188407771167967636741951941902992986043e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i) == 0.0 + 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 + 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i) == 0.0 - 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 - 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 + 0.0 i) == 1.962615573354718824241727964954454332780e-17 + 0.0 i": +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i) == 1.962615573354718824241727964954454332780e-17 + 4.148847925325683229178506116378864361396e-4916 i": +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i) == 1.962615573354718824241727964954454332780e-17 + 4.148847925325683229178506116378864361396e-4916 i": +Test "Imaginary part of: cacosh (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 + 0x1p-113 i) == 2.019699255375255198156433710951064632386e-17 + 4.767863183742677481693563511435642755521e-18 i": +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 - 0.0 i) == 1.962615573354718824241727964954454332780e-17 - 0.0 i": +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i) == 1.962615573354718824241727964954454332780e-17 - 4.148847925325683229178506116378864361396e-4916 i": +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i) == 1.962615573354718824241727964954454332780e-17 - 4.148847925325683229178506116378864361396e-4916 i": +Test "Imaginary part of: cacosh (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 - 0x1p-113 i) == 2.019699255375255198156433710951064632386e-17 - 4.767863183742677481693563511435642755521e-18 i": +Test "Real part of: cacosh (0x1.0000000000000000000000000001p0 - 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 2.119177303101063432592523199680782317447e-10 i": +Test "Imaginary part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 2.119177303101063432592523199680782317447e-10 i": +Test "Imaginary part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 2.222118384408546368406374049167636760903e-4 i": +Test "Real part of: cacosh (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 2.222118384408546368406374049167636760903e-4 i": +Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 2.222118384408546368406374049167636760903e-4 i": +Test "Real part of: cacosh (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 2.222118384408546368406374049167636760903e-4 i": +Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691638670687364 i": +Test "Imaginary part of: cacosh (0x1.fp-100 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691638670687364 i": +Test "Imaginary part of: cacosh (0x1.fp-100 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-10000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-10000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-10000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 0x1.0000000000001p0 i) == 8.813735870195431822418551933572895326024e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 0x1.0000000000001p0 i) == 8.813735870195431822418551933572895326024e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 + 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610130980e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 - 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610130980e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp16383 + 0x1.fp16383 i) == 1.135753137836666928715489992987020363057e4 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 + 1.570796326794896619231321691639734010571 i": +Test "Real part of: cacosh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 + 1.570796326794896619231321691639734010571 i": +Test "Imaginary part of: cacosh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 - 1.570796326794896619231321691639734010571 i": +Test "Real part of: cacosh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 8.813735870195430252326093249797835932642e-1 - 1.570796326794896619231321691639734010571 i": +Test "Imaginary part of: cacosh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i) == 8.813735870195430252326093249797922409363e-1 + 1.570796326794896619231321691639751305915 i": +Test "Imaginary part of: cacosh (0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i) == 8.813735870195430252326093249797922409363e-1 - 1.570796326794896619231321691639751305915 i": +Test "Imaginary part of: cacosh (0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-113 + 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 + 1.570796326794896619231321691639751374007 i": +Test "Real part of: cacosh (0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-113 - 0x1.0000000000000000000000000001p0 i) == 8.813735870195430252326093249797924452120e-1 - 1.570796326794896619231321691639751374007 i": +Test "Real part of: cacosh (0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x1p-23 + 0x1.000002p0 i) == 8.813736713132400470205730751186547909968e-1 + 1.570796242501204621739026081991856762292 i": +Test "Imaginary part of: cacosh (0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0x1p-23 - 0x1.000002p0 i) == 8.813736713132400470205730751186547909968e-1 - 1.570796242501204621739026081991856762292 i": +Test "Imaginary part of: cacosh (0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896420628589431857911675917 i": +Test "Imaginary part of: cacosh (0x1p-52 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-52 + 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910458761820e-1 + 1.570796326794896462222075823262236786996 i": +Test "Imaginary part of: cacosh (0x1p-52 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896420628589431857911675917 i": +Test "Imaginary part of: cacosh (0x1p-52 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1p-52 - 0x0.fffffffffffff8p0 i) == 8.813735870195429467279863907910458761820e-1 - 1.570796326794896462222075823262236786996 i": +Test "Imaginary part of: cacosh (0x1p-52 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619134347701278529840650 i": +Test "Imaginary part of: cacosh (0x1p-63 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 + 1.570796326794896619154657020805582738025 i": +Test "Real part of: cacosh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 + 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610131001e-1 + 1.570796326794896619154657020805582738031 i": +Test "Real part of: cacosh (0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619134347701278529840650 i": +Test "Imaginary part of: cacosh (0x1p-63 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 - 1.570796326794896619154657020805582738025 i": +Test "Real part of: cacosh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 - 0x1.0000000000000002p0 i) == 8.813735870195430253092739958139610131001e-1 - 1.570796326794896619154657020805582738031 i": +Test "Real part of: cacosh (0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p500 + 1.0 i) == 3.472667374605326000180332928505464606058e2 + 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: cacosh (0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p500 - 1.0 i) == 3.472667374605326000180332928505464606058e2 - 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: cacosh (0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p5000 + 1.0 i) == 3.466429049980286492395577839412341016946e3 + 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: cacosh (0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p5000 - 1.0 i) == 3.466429049980286492395577839412341016946e3 - 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: cacosh (0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0.25 i) == 5.097911466811016354623559941115413499164e-1 + 4.890443302710802929202843732146540079124e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Real part of: cacosh (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (1.0 + 0x1.fp-100 i) == 1.236292038260260888664514866457202186027e-15 + 1.236292038260260888664514866456887257525e-15 i": +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 + 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 + 4.247867097467650115899790787875186617316e-5 i": +Test "Real part of: cacosh (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 + 0x1p500 i) == 3.472667374605326000180332928505464606058e2 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 + 0x1p5000 i) == 3.466429049980286492395577839412341016946e3 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0.25 i) == 5.097911466811016354623559941115413499164e-1 - 4.890443302710802929202843732146540079124e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Real part of: cacosh (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (1.0 - 0x1.fp-100 i) == 1.236292038260260888664514866457202186027e-15 - 1.236292038260260888664514866456887257525e-15 i": +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 - 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 - 4.247867097467650115899790787875186617316e-5 i": +Test "Real part of: cacosh (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 - 0x1p500 i) == 3.472667374605326000180332928505464606058e2 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 - 0x1p5000 i) == 3.466429049980286492395577839412341016946e3 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i) == -0.0 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffp0 i) == -0.0 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x1.0000000000000000000000000001p0 i) == -0.0 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x1.0000000000000002p0 i) == -0.0 + 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x1.0000000000001p0 i) == -0.0 + 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i) == -0.0 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffp0 i) == -0.0 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x1.0000000000000000000000000001p0 i) == -0.0 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x1.0000000000000002p0 i) == -0.0 - 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x1.0000000000001p0 i) == -0.0 - 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.25 + 1.0 i) == -1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (-0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.25 - 1.0 i) == -1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (-0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-105 i) == -5.235987755982988730771072305465838140329e-1 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: casin (-0.5 + 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (-0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-63 i) == -5.235987755982988730771072305465838140283e-1 + 1.251928832280966098829878787499365228659e-19 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + 1.0 i) == -3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (-0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 1.0 i) == -3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-105 i) == -5.235987755982988730771072305465838140329e-1 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: casin (-0.5 - 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (-0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-63 i) == -5.235987755982988730771072305465838140283e-1 - 1.251928832280966098829878787499365228659e-19 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 1.0 i) == -3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (-0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 1.0 i) == -3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.fffffffffffff8p0 + 0.0 i) == -1.570796311893735425383665303776316016594 + 0.0 i": +Test "Real part of: casin (-0x0.fffffffffffff8p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.fffffffffffff8p0 + 0x1.fp-1025 i) == -1.570796311893735425383665303776316016594 + 3.616396521699973256461764099945789620604e-301 i": +Test "Real part of: casin (-0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i) == -1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x0.fffffffffffff8p0 - 0.0 i) == -1.570796311893735425383665303776316016594 - 0.0 i": +Test "Real part of: casin (-0x0.fffffffffffff8p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.fffffffffffff8p0 - 0x1.fp-1025 i) == -1.570796311893735425383665303776316016594 - 3.616396521699973256461764099945789620604e-301 i": +Test "Real part of: casin (-0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i) == -1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == -1.570796326794896419512475791677915736035 + 1.234330349600789959989661887846005659983e-16 i": +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == -1.570796326794896419512475791677915736035 + 1.234330349600789959989661887846005659983e-16 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == -1.570796326794896419512475791677915736035 - 1.234330349600789959989661887846005659983e-16 i": +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == -1.570796326794896419512475791677915736035 - 1.234330349600789959989661887846005659983e-16 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-112 i) == -1.570796326794896601578502908312986698624 + 1.091004200533850618345330909857103457781e-17 i": +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-112 i) == -1.570796326794896601578502908312986698624 - 1.091004200533850618345330909857103457781e-17 i": +Test "Real part of: casin (-0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffp0 + 0.0 i) == -1.570796326465624365239962068302568888898 + 0.0 i": +Test "Real part of: casin (-0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == -1.570796326465624365239962068302568888898 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Real part of: casin (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -1.570796326376055842114524927965556247908 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffp0 - 0.0 i) == -1.570796326465624365239962068302568888898 - 0.0 i": +Test "Real part of: casin (-0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == -1.570796326465624365239962068302568888898 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Real part of: casin (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -1.570796326376055842114524927965556247908 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x0.ffffffp0 + 0x1p-23 i) == -1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: casin (-0x0.ffffffp0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i) == -1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: casin (-0x0.ffffffp0 - 0x1p-23 i) == -1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: casin (-0x0.ffffffp0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i) == -1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 + 0.0 i) == -1.570796326794896619231321691639751442099 + 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i) == -1.570796326794896619231321691639751442099 + 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 + 0x1p-113 i) == -1.570796326794896614463458507897073960405 + 2.019699255375255198156433710951064632386e-17 i": +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 - 0.0 i) == -1.570796326794896619231321691639751442099 - 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i) == -1.570796326794896619231321691639751442099 - 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 - 0x1p-113 i) == -1.570796326794896614463458507897073960405 - 2.019699255375255198156433710951064632386e-17 i": +Test "Imaginary part of: casin (-0x1.0000000000000000000000000001p0 - 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.000002p0 + 0x1p-23 i) == -1.570574114956455764594481054234834678422 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.000002p0 - 0x1p-23 i) == -1.570574114956455764594481054234834678422 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (-0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (-0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i) == -1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i) == -1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i) == -1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i) == -1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-10000 + 1.0 i) == -6.867047849047171855399183659351043150871e-3011 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-10000 - 1.0 i) == -6.867047849047171855399183659351043150871e-3011 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 0.5 i) == -4.819934639999230680322935210539402497827e-309 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i) == -3.810492908885321954658152505985270452320e-309 + 8.813735870195429467279863907910371604180e-1 i": +Test "Real part of: casin (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i) == -3.810492908885321743133304375216641110205e-309 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 0x1.0000000000001p0 i) == -3.810492908885321320083608113679347200012e-309 + 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i) == -3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i) == -2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 0.5 i) == -4.819934639999230680322935210539402497827e-309 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i) == -3.810492908885321954658152505985270452320e-309 - 8.813735870195429467279863907910371604180e-1 i": +Test "Real part of: casin (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i) == -3.810492908885321743133304375216641110205e-309 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 0x1.0000000000001p0 i) == -3.810492908885321320083608113679347200012e-309 - 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i) == -3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i) == -2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i) == -2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i) == -2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i) == -1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i) == -2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i) == -2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i) == -1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 + 0.5 i) == -7.282957076134209141226696333885150260319e-4933 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == -5.757683115456107044287327268904964422212e-4933 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i) == -5.757683115456107044131264955348448400014e-4933 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 + 0x1.0000000000000002p0 i) == -5.757683115456107043819140328235418018963e-4933 + 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 + 1.0 i) == -5.757683115456107044131264955348448954458e-4933 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 + 1.5 i) == -4.516698239814521372306784062043266700598e-4933 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 - 0.5 i) == -7.282957076134209141226696333885150260319e-4933 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == -5.757683115456107044287327268904964422212e-4933 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i) == -5.757683115456107044131264955348448400014e-4933 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 - 0x1.0000000000000002p0 i) == -5.757683115456107043819140328235418018963e-4933 - 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 - 1.0 i) == -5.757683115456107044131264955348448954458e-4933 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 - 1.5 i) == -4.516698239814521372306784062043266700598e-4933 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (-0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (-0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-105 + 0.5 i) == -2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == -1.743152798421049375791483240187377443526e-32 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-105 - 0.5 i) == -2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == -1.743152798421049375791483240187377443526e-32 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-112 + 0.5 i) == -1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-112 - 0.5 i) == -1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-113 + 0x1.0000000000000000000000000001p0 i) == -6.809190618832224124185481406981900518193e-35 + 8.813735870195430252326093249797924452120e-1 i": +Test "Real part of: casin (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-113 + 0x1.0000000000000000000000000001p0 i) == -6.809190618832224124185481406981900518193e-35 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-113 - 0x1.0000000000000000000000000001p0 i) == -6.809190618832224124185481406981900518193e-35 - 8.813735870195430252326093249797924452120e-1 i": +Test "Real part of: casin (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-113 - 0x1.0000000000000000000000000001p0 i) == -6.809190618832224124185481406981900518193e-35 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-52 + 0.5 i) == -1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: casin (-0x1p-52 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-52 + 0.5 i) == -1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-52 + 0x1.0000000000001p0 i) == -1.570092458683774885078102529858632363236e-16 + 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (-0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-52 - 0.5 i) == -1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: casin (-0x1p-52 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-52 - 0.5 i) == -1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-52 - 0x1.0000000000001p0 i) == -1.570092458683774885078102529858632363236e-16 - 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (-0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0.5 i) == -9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i) == -7.666467083416870406778649849746878368519e-20 + 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i) == -7.666467083416870406778649849746878368519e-20 + 8.813735870195430253092739958139610131001e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0.5 i) == -9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i) == -7.666467083416870406778649849746878368519e-20 - 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i) == -7.666467083416870406778649849746878368519e-20 - 8.813735870195430253092739958139610131001e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p500 + 1.0 i) == -1.570796326794896619231321691639751442099 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p500 - 1.0 i) == -1.570796326794896619231321691639751442099 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p5000 + 1.0 i) == -1.570796326794896619231321691639751442099 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p5000 - 1.0 i) == -1.570796326794896619231321691639751442099 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 + 0.25 i) == -1.081751996523816326311037318425097434186 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (-1.0 + 0.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 + 0x1.fp-129 i) == -1.570796326794896619177965338869929107115 + 5.335635276982233498398987585285818977933e-20 i": +Test "Real part of: casin (-1.0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1.fp-30 i) == -1.570753848123921942730162693731872690232 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1p500 i) == -3.054936363499604682051979393213617699789e-151 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1p5000 i) == -7.079811261048172892385615158694057552948e-1506 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 - 0.25 i) == -1.081751996523816326311037318425097434186 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (-1.0 - 0.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 - 0x1.fp-129 i) == -1.570796326794896619177965338869929107115 - 5.335635276982233498398987585285818977933e-20 i": +Test "Real part of: casin (-1.0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1.fp-30 i) == -1.570753848123921942730162693731872690232 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1p500 i) == -3.054936363499604682051979393213617699789e-151 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (-1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1p5000 i) == -7.079811261048172892385615158694057552948e-1506 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (-1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i) == 0.0 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffp0 i) == 0.0 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x1.0000000000000000000000000001p0 i) == 0.0 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (0.0 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x1.0000000000000002p0 i) == 0.0 + 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: casin (0.0 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x1.0000000000001p0 i) == 0.0 + 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: casin (0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i) == 0.0 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffp0 i) == 0.0 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x1.0000000000000000000000000001p0 i) == 0.0 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (0.0 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x1.0000000000000002p0 i) == 0.0 - 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: casin (0.0 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x1.0000000000001p0 i) == 0.0 - 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: casin (0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.25 + 1.0 i) == 1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.25 - 1.0 i) == 1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-105 i) == 5.235987755982988730771072305465838140329e-1 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (0.5 + 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: casin (0.5 + 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (0.5 + 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-63 i) == 5.235987755982988730771072305465838140283e-1 + 1.251928832280966098829878787499365228659e-19 i": +Test "Imaginary part of: casin (0.5 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + 1.0 i) == 3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 1.0 i) == 3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-105 i) == 5.235987755982988730771072305465838140329e-1 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (0.5 - 0x1p-105 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: casin (0.5 - 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (0.5 - 0x1p-112 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-63 i) == 5.235987755982988730771072305465838140283e-1 - 1.251928832280966098829878787499365228659e-19 i": +Test "Imaginary part of: casin (0.5 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 1.0 i) == 3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 1.0 i) == 3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: casin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.fffffffffffff8p0 + 0.0 i) == 1.570796311893735425383665303776316016594 + 0.0 i": +Test "Real part of: casin (0x0.fffffffffffff8p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.fffffffffffff8p0 + 0x1.fp-1025 i) == 1.570796311893735425383665303776316016594 + 3.616396521699973256461764099945789620604e-301 i": +Test "Real part of: casin (0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x0.fffffffffffff8p0 - 0.0 i) == 1.570796311893735425383665303776316016594 - 0.0 i": +Test "Real part of: casin (0x0.fffffffffffff8p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.fffffffffffff8p0 - 0x1.fp-1025 i) == 1.570796311893735425383665303776316016594 - 3.616396521699973256461764099945789620604e-301 i": +Test "Real part of: casin (0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == 1.570796326794896419512475791677915736035 + 1.234330349600789959989661887846005659983e-16 i": +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == 1.570796326794896419512475791677915736035 + 1.234330349600789959989661887846005659983e-16 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == 1.570796326794896419512475791677915736035 - 1.234330349600789959989661887846005659983e-16 i": +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == 1.570796326794896419512475791677915736035 - 1.234330349600789959989661887846005659983e-16 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-112 i) == 1.570796326794896601578502908312986698624 + 1.091004200533850618345330909857103457781e-17 i": +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-112 i) == 1.570796326794896601578502908312986698624 - 1.091004200533850618345330909857103457781e-17 i": +Test "Real part of: casin (0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-112 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffp0 + 0.0 i) == 1.570796326465624365239962068302568888898 + 0.0 i": +Test "Real part of: casin (0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 1.570796326465624365239962068302568888898 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Real part of: casin (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 1.570796326376055842114524927965556247908 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffp0 - 0.0 i) == 1.570796326465624365239962068302568888898 - 0.0 i": +Test "Real part of: casin (0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 1.570796326465624365239962068302568888898 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Real part of: casin (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 1.570796326376055842114524927965556247908 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x0.ffffffp0 + 0x1p-23 i) == 1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: casin (0x0.ffffffp0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i) == 1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: casin (0x0.ffffffp0 - 0x1p-23 i) == 1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: casin (0x0.ffffffp0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i) == 1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 + 0.0 i) == 1.570796326794896619231321691639751442099 + 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i) == 1.570796326794896619231321691639751442099 + 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 + 0x1p-113 i) == 1.570796326794896614463458507897073960405 + 2.019699255375255198156433710951064632386e-17 i": +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 - 0.0 i) == 1.570796326794896619231321691639751442099 - 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i) == 1.570796326794896619231321691639751442099 - 1.962615573354718824241727964954454332780e-17 i": +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 - 0x1p-113 i) == 1.570796326794896614463458507897073960405 - 2.019699255375255198156433710951064632386e-17 i": +Test "Imaginary part of: casin (0x1.0000000000000000000000000001p0 - 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.000002p0 + 0x1p-23 i) == 1.570574114956455764594481054234834678422 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.000002p0 - 0x1p-23 i) == 1.570574114956455764594481054234834678422 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i) == 1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i) == 1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i) == 1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i) == 1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-10000 + 1.0 i) == 6.867047849047171855399183659351043150871e-3011 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-10000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-10000 - 1.0 i) == 6.867047849047171855399183659351043150871e-3011 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 0.5 i) == 4.819934639999230680322935210539402497827e-309 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-1025 + 0x0.fffffffffffff8p0 i) == 3.810492908885321954658152505985270452320e-309 + 8.813735870195429467279863907910371604180e-1 i": +Test "Real part of: casin (0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i) == 3.810492908885321743133304375216641110205e-309 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 0x1.0000000000001p0 i) == 3.810492908885321320083608113679347200012e-309 + 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i) == 3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i) == 2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 0.5 i) == 4.819934639999230680322935210539402497827e-309 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-1025 - 0x0.fffffffffffff8p0 i) == 3.810492908885321954658152505985270452320e-309 - 8.813735870195429467279863907910371604180e-1 i": +Test "Real part of: casin (0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i) == 3.810492908885321743133304375216641110205e-309 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 0x1.0000000000001p0 i) == 3.810492908885321320083608113679347200012e-309 - 8.813735870195431822418551933572895326024e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i) == 3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i) == 2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i) == 2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i) == 2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i) == 1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i) == 2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i) == 2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i) == 1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 + 0.5 i) == 7.282957076134209141226696333885150260319e-4933 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 5.757683115456107044287327268904964422212e-4933 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i) == 5.757683115456107044131264955348448400014e-4933 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 + 0x1.0000000000000002p0 i) == 5.757683115456107043819140328235418018963e-4933 + 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 + 1.0 i) == 5.757683115456107044131264955348448954458e-4933 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 + 1.5 i) == 4.516698239814521372306784062043266700598e-4933 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 - 0.5 i) == 7.282957076134209141226696333885150260319e-4933 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 5.757683115456107044287327268904964422212e-4933 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i) == 5.757683115456107044131264955348448400014e-4933 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 - 0x1.0000000000000002p0 i) == 5.757683115456107043819140328235418018963e-4933 - 8.813735870195430253092739958139610130980e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 - 1.0 i) == 5.757683115456107044131264955348448954458e-4933 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 - 1.5 i) == 4.516698239814521372306784062043266700598e-4933 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 + 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 + 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp16383 + 0x1.fp16383 i) == 7.853981633974483096156608458198757210493e-1 + 1.135753137836666928715489992987020363057e4 i": +Test "Imaginary part of: casin (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-105 + 0.5 i) == 2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.743152798421049375791483240187377443526e-32 + 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-105 - 0.5 i) == 2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.743152798421049375791483240187377443526e-32 - 8.813735870195430252326093249797835932642e-1 i": +Test "Imaginary part of: casin (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-112 + 0.5 i) == 1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-112 - 0.5 i) == 1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1p-113 + 0x1.0000000000000000000000000001p0 i) == 6.809190618832224124185481406981900518193e-35 + 8.813735870195430252326093249797924452120e-1 i": +Test "Real part of: casin (0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-113 + 0x1.0000000000000000000000000001p0 i) == 6.809190618832224124185481406981900518193e-35 + 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-113 - 0x1.0000000000000000000000000001p0 i) == 6.809190618832224124185481406981900518193e-35 - 8.813735870195430252326093249797924452120e-1 i": +Test "Real part of: casin (0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-113 - 0x1.0000000000000000000000000001p0 i) == 6.809190618832224124185481406981900518193e-35 - 8.813735870195430252326093249797924452120e-1 i": +Test "Imaginary part of: casin (0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-52 + 0.5 i) == 1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: casin (0x1p-52 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-52 + 0.5 i) == 1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-52 + 0x1.0000000000001p0 i) == 1.570092458683774885078102529858632363236e-16 + 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-52 - 0.5 i) == 1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: casin (0x1p-52 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-52 - 0.5 i) == 1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-52 - 0x1.0000000000001p0 i) == 1.570092458683774885078102529858632363236e-16 - 8.813735870195431822418551933572982483664e-1 i": +Test "Real part of: casin (0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 + 0.5 i) == 9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 + 0x1.0000000000000002p0 i) == 7.666467083416870406778649849746878368519e-20 + 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 + 0x1.0000000000000002p0 i) == 7.666467083416870406778649849746878368519e-20 + 8.813735870195430253092739958139610131001e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 - 0.5 i) == 9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 - 0x1.0000000000000002p0 i) == 7.666467083416870406778649849746878368519e-20 - 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 - 0x1.0000000000000002p0 i) == 7.666467083416870406778649849746878368519e-20 - 8.813735870195430253092739958139610131001e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p500 + 1.0 i) == 1.570796326794896619231321691639751442099 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p500 - 1.0 i) == 1.570796326794896619231321691639751442099 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p5000 + 1.0 i) == 1.570796326794896619231321691639751442099 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p5000 - 1.0 i) == 1.570796326794896619231321691639751442099 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 + 0.25 i) == 1.081751996523816326311037318425097434186 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (1.0 + 0.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 + 0x1.fp-129 i) == 1.570796326794896619177965338869929107115 + 5.335635276982233498398987585285818977933e-20 i": +Test "Real part of: casin (1.0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1.fp-30 i) == 1.570753848123921942730162693731872690232 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1p500 i) == 3.054936363499604682051979393213617699789e-151 + 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1p5000 i) == 7.079811261048172892385615158694057552948e-1506 + 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 - 0.25 i) == 1.081751996523816326311037318425097434186 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (1.0 - 0.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 - 0x1.fp-129 i) == 1.570796326794896619177965338869929107115 - 5.335635276982233498398987585285818977933e-20 i": +Test "Real part of: casin (1.0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1.fp-30 i) == 1.570753848123921942730162693731872690232 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1p500 i) == 3.054936363499604682051979393213617699789e-151 - 3.472667374605326000180332928505464606058e2 i": +Test "Imaginary part of: casin (1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1p5000 i) == 7.079811261048172892385615158694057552948e-1506 - 3.466429049980286492395577839412341016946e3 i": +Test "Imaginary part of: casin (1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": double: 1 float: 1 idouble: 1 @@ -4155,2646 +4155,2646 @@ ildouble: 1 ldouble: 1 # casinh -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.0 + 0x0.fffffffffffff8p0 i) == -0.0 + 1.570796311893735425383665303776316016594 i": +Test "Imaginary part of: casinh (-0.0 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.0 + 0x0.ffffffffffffffffp0 i) == -0.0 + 1.570796326465624365239962068302568888898 i": +Test "Imaginary part of: casinh (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.0 + 0x1.0000000000000000000000000001p0 i) == -1.962615573354718824241727964954454332780e-17 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0.0 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.0 - 0x0.fffffffffffff8p0 i) == -0.0 - 1.570796311893735425383665303776316016594 i": +Test "Imaginary part of: casinh (-0.0 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.0 - 0x0.ffffffffffffffffp0 i) == -0.0 - 1.570796326465624365239962068302568888898 i": +Test "Imaginary part of: casinh (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.0 - 0x1.0000000000000000000000000001p0 i) == -1.962615573354718824241727964954454332780e-17 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0.0 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.25 + 1.0 i) == -5.097911466811016354623559941115413499164e-1 + 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (-0.25 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.25 - 1.0 i) == -5.097911466811016354623559941115413499164e-1 - 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (-0.25 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 0x1.fp-1025 i) == -4.812118250596034474977589134243684231352e-1 + 4.819934639999230680322935210539402497827e-309 i": +Test "Real part of: casinh (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 0x1.fp-16385 i) == -4.812118250596034474977589134243684231352e-1 + 7.282957076134209141226696333885150260319e-4933 i": +Test "Real part of: casinh (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-0.5 + 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 + 0x1p-52 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.5 + 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Imaginary part of: casinh (-0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0x1.fp-1025 i) == -4.812118250596034474977589134243684231352e-1 - 4.819934639999230680322935210539402497827e-309 i": +Test "Real part of: casinh (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0x1.fp-16385 i) == -4.812118250596034474977589134243684231352e-1 - 7.282957076134209141226696333885150260319e-4933 i": +Test "Real part of: casinh (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-0.5 - 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 - 0x1p-52 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.5 - 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Imaginary part of: casinh (-0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0x0.fffffffffffff8p0 + 0x1.fp-1025 i) == -8.813735870195429467279863907910371604180e-1 + 3.810492908885321954658152505985270452320e-309 i": +Test "Imaginary part of: casinh (-0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x0.fffffffffffff8p0 - 0x1.fp-1025 i) == -8.813735870195429467279863907910371604180e-1 - 3.810492908885321954658152505985270452320e-309 i": +Test "Imaginary part of: casinh (-0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0.0 i) == -8.813735870195430252326093249797835932642e-1 + 0.0 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i) == -8.813735870195430252326093249797835932642e-1 + 3.810492908885321743133304375216641110205e-309 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == -8.813735870195430252326093249797835932642e-1 + 1.743152798421049375791483240187377443526e-32 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0.0 i) == -8.813735870195430252326093249797835932642e-1 - 0.0 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i) == -8.813735870195430252326093249797835932642e-1 - 3.810492908885321743133304375216641110205e-309 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == -8.813735870195430252326093249797835932642e-1 - 1.743152798421049375791483240187377443526e-32 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0.0 i) == -8.813735870195430251942769895627079569917e-1 + 0.0 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == -8.813735870195430251942769895627079569917e-1 + 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0.0 i) == -8.813735870195430251942769895627079569917e-1 - 0.0 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == -8.813735870195430251942769895627079569917e-1 - 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 + 0.0 i) == -8.813735870195430252326093249797924452120e-1 + 0.0 i": +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i) == -8.813735870195430252326093249797924452120e-1 + 5.757683115456107044131264955348448400014e-4933 i": +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 + 0x1p-113 i) == -8.813735870195430252326093249797924452120e-1 + 6.809190618832224124185481406981900518193e-35 i": +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000000000000000000001p0 + 0x1p-113 i) == -8.813735870195430252326093249797924452120e-1 + 6.809190618832224124185481406981900518193e-35 i": +Test "Imaginary part of: casinh (-0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 - 0.0 i) == -8.813735870195430252326093249797924452120e-1 - 0.0 i": +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i) == -8.813735870195430252326093249797924452120e-1 - 5.757683115456107044131264955348448400014e-4933 i": +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 - 0x1p-113 i) == -8.813735870195430252326093249797924452120e-1 - 6.809190618832224124185481406981900518193e-35 i": +Test "Real part of: casinh (-0x1.0000000000000000000000000001p0 - 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000000000000000000001p0 - 0x1p-113 i) == -8.813735870195430252326093249797924452120e-1 - 6.809190618832224124185481406981900518193e-35 i": +Test "Imaginary part of: casinh (-0x1.0000000000000000000000000001p0 - 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000002p0 + 0.0 i) == -8.813735870195430253092739958139610130980e-1 + 0.0 i": +Test "Real part of: casinh (-0x1.0000000000000002p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000002p0 + 0x1.fp-16385 i) == -8.813735870195430253092739958139610130980e-1 + 5.757683115456107043819140328235418018963e-4933 i": +Test "Real part of: casinh (-0x1.0000000000000002p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i) == -8.813735870195430253092739958139610131001e-1 + 7.666467083416870406778649849746878368519e-20 i": +Test "Real part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i) == -8.813735870195430253092739958139610131001e-1 + 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000002p0 - 0.0 i) == -8.813735870195430253092739958139610130980e-1 - 0.0 i": +Test "Real part of: casinh (-0x1.0000000000000002p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000002p0 - 0x1.fp-16385 i) == -8.813735870195430253092739958139610130980e-1 - 5.757683115456107043819140328235418018963e-4933 i": +Test "Real part of: casinh (-0x1.0000000000000002p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i) == -8.813735870195430253092739958139610131001e-1 - 7.666467083416870406778649849746878368519e-20 i": +Test "Real part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i) == -8.813735870195430253092739958139610131001e-1 - 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000001p0 + 0.0 i) == -8.813735870195431822418551933572895326024e-1 + 0.0 i": +Test "Real part of: casinh (-0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000001p0 + 0x1.fp-1025 i) == -8.813735870195431822418551933572895326024e-1 + 3.810492908885321320083608113679347200012e-309 i": +Test "Real part of: casinh (-0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000001p0 + 0x1p-52 i) == -8.813735870195431822418551933572982483664e-1 + 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000001p0 - 0.0 i) == -8.813735870195431822418551933572895326024e-1 - 0.0 i": +Test "Real part of: casinh (-0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.0000000000001p0 - 0x1.fp-1025 i) == -8.813735870195431822418551933572895326024e-1 - 3.810492908885321320083608113679347200012e-309 i": +Test "Real part of: casinh (-0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000001p0 - 0x1p-52 i) == -8.813735870195431822418551933572982483664e-1 - 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-10 + 1.0 i) == -4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (-0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-10 - 1.0 i) == -4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (-0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i) == -3.616396521699973256461764099945789620604e-301 + 1.570796311893735425383665303776316016594 i": +Test "Imaginary part of: casinh (-0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i) == -3.616396521699973256461764099945789620604e-301 - 1.570796311893735425383665303776316016594 i": +Test "Imaginary part of: casinh (-0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 + 0.5 i) == -3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-129 + 1.0 i) == -5.335635276982233498398987585285818977933e-20 + 1.570796326794896619177965338869929107115 i": +Test "Imaginary part of: casinh (-0x1.fp-129 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 - 0.5 i) == -3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-129 - 1.0 i) == -5.335635276982233498398987585285818977933e-20 - 1.570796326794896619177965338869929107115 i": +Test "Imaginary part of: casinh (-0x1.fp-129 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == -2.472906068161537187835415298076415423459e-4923 + 1.570796326465624365239962068302568888898 i": +Test "Imaginary part of: casinh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i) == -1.962615573354718824241727964954454332780e-17 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == -2.472906068161537187835415298076415423459e-4923 - 1.570796326465624365239962068302568888898 i": +Test "Imaginary part of: casinh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i) == -1.962615573354718824241727964954454332780e-17 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-30 + 1.0 i) == -4.247867098745151888768727039216644758847e-5 + 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (-0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-30 - 1.0 i) == -4.247867098745151888768727039216644758847e-5 - 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (-0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-105 + 0.5 i) == -2.846556599890768890940941645338546615370e-32 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-105 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == -1.234330349600789959989661887846005659983e-16 + 1.570796326794896419512475791677915736035 i": +Test "Real part of: casinh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == -1.234330349600789959989661887846005659983e-16 + 1.570796326794896419512475791677915736035 i": +Test "Imaginary part of: casinh (-0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-105 - 0.5 i) == -2.846556599890768890940941645338546615370e-32 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-105 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == -1.234330349600789959989661887846005659983e-16 - 1.570796326794896419512475791677915736035 i": +Test "Real part of: casinh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == -1.234330349600789959989661887846005659983e-16 - 1.570796326794896419512475791677915736035 i": +Test "Imaginary part of: casinh (-0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-112 + 0.5 i) == -2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-112 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-112 + 0.5 i) == -2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (-0x1p-112 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i) == -1.091004200533850618345330909857103457781e-17 + 1.570796326794896601578502908312986698624 i": +Test "Imaginary part of: casinh (-0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-112 - 0.5 i) == -2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-112 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-112 - 0.5 i) == -2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (-0x1p-112 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i) == -1.091004200533850618345330909857103457781e-17 - 1.570796326794896601578502908312986698624 i": +Test "Imaginary part of: casinh (-0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-113 + 0x1.0000000000000000000000000001p0 i) == -2.019699255375255198156433710951064632386e-17 + 1.570796326794896614463458507897073960405 i": +Test "Real part of: casinh (-0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-113 - 0x1.0000000000000000000000000001p0 i) == -2.019699255375255198156433710951064632386e-17 - 1.570796326794896614463458507897073960405 i": +Test "Real part of: casinh (-0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0.5 i) == -1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-23 + 0.5 i) == -1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (-0x1p-23 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casinh (-0x1p-23 + 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Imaginary part of: casinh (-0x1p-23 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0x1.000002p0 i) == -5.364668491573609633134147164031476452679e-4 + 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (-0x1p-23 + 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0.5 i) == -1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1p-23 - 0.5 i) == -1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (-0x1p-23 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casinh (-0x1p-23 - 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Imaginary part of: casinh (-0x1p-23 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0x1.000002p0 i) == -5.364668491573609633134147164031476452679e-4 - 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (-0x1p-23 - 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-63 + 0.5 i) == -1.251928832280966098829878787499365228659e-19 + 5.235987755982988730771072305465838140283e-1 i": +Test "Real part of: casinh (-0x1p-63 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -2.588578361325995866221775673638805081337e-10 + 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 - 0.5 i) == -1.251928832280966098829878787499365228659e-19 - 5.235987755982988730771072305465838140283e-1 i": +Test "Real part of: casinh (-0x1p-63 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -2.588578361325995866221775673638805081337e-10 - 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p500 + 1.0 i) == -3.472667374605326000180332928505464606058e2 + 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (-0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p500 - 1.0 i) == -3.472667374605326000180332928505464606058e2 - 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (-0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p5000 + 1.0 i) == -3.466429049980286492395577839412341016946e3 + 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (-0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p5000 - 1.0 i) == -3.466429049980286492395577839412341016946e3 - 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (-0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Real part of: casinh (-1.0 + 0.25 i) == -8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (-1.0 + 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0.5 i) == -9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0.5 i) == -9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (-1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-10000 i) == -8.813735870195430252326093249797923090282e-1 + 6.867047849047171855399183659351043150871e-3011 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-16385 i) == -8.813735870195430252326093249797923090282e-1 + 5.757683115456107044131264955348448954458e-4933 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1p500 i) == -3.472667374605326000180332928505464606058e2 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1p5000 i) == -3.466429049980286492395577839412341016946e3 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Real part of: casinh (-1.0 - 0.25 i) == -8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (-1.0 - 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0.5 i) == -9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0.5 i) == -9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (-1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-10000 i) == -8.813735870195430252326093249797923090282e-1 - 6.867047849047171855399183659351043150871e-3011 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-16385 i) == -8.813735870195430252326093249797923090282e-1 - 5.757683115456107044131264955348448954458e-4933 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1p500 i) == -3.472667374605326000180332928505464606058e2 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1p5000 i) == -3.466429049980286492395577839412341016946e3 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-16385 i) == -1.194763217287109304111930828519090523536 + 4.516698239814521372306784062043266700598e-4933 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-16385 i) == -1.194763217287109304111930828519090523536 - 4.516698239814521372306784062043266700598e-4933 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": double: 5 float: 1 idouble: 5 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Imaginary part of: casinh (-2 - 3 i)": double: 3 float: 6 idouble: 3 ifloat: 6 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casinh (0.0 + 0x0.fffffffffffff8p0 i) == 0.0 + 1.570796311893735425383665303776316016594 i": +Test "Imaginary part of: casinh (0.0 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.0 + 0x0.ffffffffffffffffp0 i) == 0.0 + 1.570796326465624365239962068302568888898 i": +Test "Imaginary part of: casinh (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.0 + 0x1.0000000000000000000000000001p0 i) == 1.962615573354718824241727964954454332780e-17 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0.0 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.0 - 0x0.fffffffffffff8p0 i) == 0.0 - 1.570796311893735425383665303776316016594 i": +Test "Imaginary part of: casinh (0.0 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.0 - 0x0.ffffffffffffffffp0 i) == 0.0 - 1.570796326465624365239962068302568888898 i": +Test "Imaginary part of: casinh (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.0 - 0x1.0000000000000000000000000001p0 i) == 1.962615573354718824241727964954454332780e-17 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0.0 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.25 + 1.0 i) == 5.097911466811016354623559941115413499164e-1 + 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (0.25 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.25 - 1.0 i) == 5.097911466811016354623559941115413499164e-1 - 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (0.25 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 0x1.fp-1025 i) == 4.812118250596034474977589134243684231352e-1 + 4.819934639999230680322935210539402497827e-309 i": +Test "Real part of: casinh (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 0x1.fp-16385 i) == 4.812118250596034474977589134243684231352e-1 + 7.282957076134209141226696333885150260319e-4933 i": +Test "Real part of: casinh (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 + 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0.5 + 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 + 0x1p-52 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.5 + 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Imaginary part of: casinh (0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0x1.fp-1025 i) == 4.812118250596034474977589134243684231352e-1 - 4.819934639999230680322935210539402497827e-309 i": +Test "Real part of: casinh (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0x1.fp-16385 i) == 4.812118250596034474977589134243684231352e-1 - 7.282957076134209141226696333885150260319e-4933 i": +Test "Real part of: casinh (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 - 0x1p-23 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0.5 - 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 - 0x1p-52 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.5 - 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Imaginary part of: casinh (0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x0.fffffffffffff8p0 + 0x1.fp-1025 i) == 8.813735870195429467279863907910371604180e-1 + 3.810492908885321954658152505985270452320e-309 i": +Test "Imaginary part of: casinh (0x0.fffffffffffff8p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x0.fffffffffffff8p0 - 0x1.fp-1025 i) == 8.813735870195429467279863907910371604180e-1 - 3.810492908885321954658152505985270452320e-309 i": +Test "Imaginary part of: casinh (0x0.fffffffffffff8p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i) == 8.813735870195430252326093249797835932642e-1 + 0.0 i": +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i) == 8.813735870195430252326093249797835932642e-1 + 3.810492908885321743133304375216641110205e-309 i": +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i) == 8.813735870195430252326093249797835932642e-1 + 1.743152798421049375791483240187377443526e-32 i": +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 + 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i) == 8.813735870195430252326093249797835932642e-1 - 0.0 i": +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i) == 8.813735870195430252326093249797835932642e-1 - 3.810492908885321743133304375216641110205e-309 i": +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i) == 8.813735870195430252326093249797835932642e-1 - 1.743152798421049375791483240187377443526e-32 i": +Test "Real part of: casinh (0x0.ffffffffffffffffffffffffffcp0 - 0x1p-105 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0.0 i) == 8.813735870195430251942769895627079569917e-1 + 0.0 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 8.813735870195430251942769895627079569917e-1 + 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0.0 i) == 8.813735870195430251942769895627079569917e-1 - 0.0 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 8.813735870195430251942769895627079569917e-1 - 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.0000000000000000000000000001p0 + 0.0 i) == 8.813735870195430252326093249797924452120e-1 + 0.0 i": +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i) == 8.813735870195430252326093249797924452120e-1 + 5.757683115456107044131264955348448400014e-4933 i": +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000000000000000001p0 + 0x1p-113 i) == 8.813735870195430252326093249797924452120e-1 + 6.809190618832224124185481406981900518193e-35 i": +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000000000000000000001p0 + 0x1p-113 i) == 8.813735870195430252326093249797924452120e-1 + 6.809190618832224124185481406981900518193e-35 i": +Test "Imaginary part of: casinh (0x1.0000000000000000000000000001p0 + 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000000000000000001p0 - 0.0 i) == 8.813735870195430252326093249797924452120e-1 - 0.0 i": +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i) == 8.813735870195430252326093249797924452120e-1 - 5.757683115456107044131264955348448400014e-4933 i": +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000000000000000001p0 - 0x1p-113 i) == 8.813735870195430252326093249797924452120e-1 - 6.809190618832224124185481406981900518193e-35 i": +Test "Real part of: casinh (0x1.0000000000000000000000000001p0 - 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000000000000000000001p0 - 0x1p-113 i) == 8.813735870195430252326093249797924452120e-1 - 6.809190618832224124185481406981900518193e-35 i": +Test "Imaginary part of: casinh (0x1.0000000000000000000000000001p0 - 0x1p-113 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000002p0 + 0.0 i) == 8.813735870195430253092739958139610130980e-1 + 0.0 i": +Test "Real part of: casinh (0x1.0000000000000002p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000002p0 + 0x1.fp-16385 i) == 8.813735870195430253092739958139610130980e-1 + 5.757683115456107043819140328235418018963e-4933 i": +Test "Real part of: casinh (0x1.0000000000000002p0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i) == 8.813735870195430253092739958139610131001e-1 + 7.666467083416870406778649849746878368519e-20 i": +Test "Real part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i) == 8.813735870195430253092739958139610131001e-1 + 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000002p0 - 0.0 i) == 8.813735870195430253092739958139610130980e-1 - 0.0 i": +Test "Real part of: casinh (0x1.0000000000000002p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000002p0 - 0x1.fp-16385 i) == 8.813735870195430253092739958139610130980e-1 - 5.757683115456107043819140328235418018963e-4933 i": +Test "Real part of: casinh (0x1.0000000000000002p0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i) == 8.813735870195430253092739958139610131001e-1 - 7.666467083416870406778649849746878368519e-20 i": +Test "Real part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i) == 8.813735870195430253092739958139610131001e-1 - 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000001p0 + 0.0 i) == 8.813735870195431822418551933572895326024e-1 + 0.0 i": +Test "Real part of: casinh (0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000001p0 + 0x1.fp-1025 i) == 8.813735870195431822418551933572895326024e-1 + 3.810492908885321320083608113679347200012e-309 i": +Test "Real part of: casinh (0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000001p0 + 0x1p-52 i) == 8.813735870195431822418551933572982483664e-1 + 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000001p0 - 0.0 i) == 8.813735870195431822418551933572895326024e-1 - 0.0 i": +Test "Real part of: casinh (0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.0000000000001p0 - 0x1.fp-1025 i) == 8.813735870195431822418551933572895326024e-1 - 3.810492908885321320083608113679347200012e-309 i": +Test "Real part of: casinh (0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000001p0 - 0x1p-52 i) == 8.813735870195431822418551933572982483664e-1 - 1.570092458683774885078102529858632363236e-16 i": +Test "Imaginary part of: casinh (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-10 + 1.0 i) == 4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-10 - 1.0 i) == 4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-1025 + 0x0.fffffffffffff8p0 i) == 3.616396521699973256461764099945789620604e-301 + 1.570796311893735425383665303776316016594 i": +Test "Imaginary part of: casinh (0x1.fp-1025 + 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-1025 - 0x0.fffffffffffff8p0 i) == 3.616396521699973256461764099945789620604e-301 - 1.570796311893735425383665303776316016594 i": +Test "Imaginary part of: casinh (0x1.fp-1025 - 0x0.fffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 + 0.5 i) == 3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1.fp-129 + 1.0 i) == 5.335635276982233498398987585285818977933e-20 + 1.570796326794896619177965338869929107115 i": +Test "Imaginary part of: casinh (0x1.fp-129 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 - 0.5 i) == 3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1.fp-129 - 1.0 i) == 5.335635276982233498398987585285818977933e-20 - 1.570796326794896619177965338869929107115 i": +Test "Imaginary part of: casinh (0x1.fp-129 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 2.472906068161537187835415298076415423459e-4923 + 1.570796326465624365239962068302568888898 i": +Test "Imaginary part of: casinh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i) == 1.962615573354718824241727964954454332780e-17 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-16385 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 2.472906068161537187835415298076415423459e-4923 - 1.570796326465624365239962068302568888898 i": +Test "Imaginary part of: casinh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i) == 1.962615573354718824241727964954454332780e-17 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-16385 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-30 + 1.0 i) == 4.247867098745151888768727039216644758847e-5 + 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-30 - 1.0 i) == 4.247867098745151888768727039216644758847e-5 - 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp16383 + 0x1.fp16383 i) == 1.135753137836666928715489992987020363057e4 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-105 + 0.5 i) == 2.846556599890768890940941645338546615370e-32 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-105 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.234330349600789959989661887846005659983e-16 + 1.570796326794896419512475791677915736035 i": +Test "Real part of: casinh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i) == 1.234330349600789959989661887846005659983e-16 + 1.570796326794896419512475791677915736035 i": +Test "Imaginary part of: casinh (0x1p-105 + 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-105 - 0.5 i) == 2.846556599890768890940941645338546615370e-32 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-105 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.234330349600789959989661887846005659983e-16 - 1.570796326794896419512475791677915736035 i": +Test "Real part of: casinh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i) == 1.234330349600789959989661887846005659983e-16 - 1.570796326794896419512475791677915736035 i": +Test "Imaginary part of: casinh (0x1p-105 - 0x0.ffffffffffffffffffffffffffcp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-112 + 0.5 i) == 2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-112 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-112 + 0.5 i) == 2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (0x1p-112 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i) == 1.091004200533850618345330909857103457781e-17 + 1.570796326794896601578502908312986698624 i": +Test "Imaginary part of: casinh (0x1p-112 + 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-112 - 0.5 i) == 2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-112 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-112 - 0.5 i) == 2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Imaginary part of: casinh (0x1p-112 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i) == 1.091004200533850618345330909857103457781e-17 - 1.570796326794896601578502908312986698624 i": +Test "Imaginary part of: casinh (0x1p-112 - 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-113 + 0x1.0000000000000000000000000001p0 i) == 2.019699255375255198156433710951064632386e-17 + 1.570796326794896614463458507897073960405 i": +Test "Real part of: casinh (0x1p-113 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-113 - 0x1.0000000000000000000000000001p0 i) == 2.019699255375255198156433710951064632386e-17 - 1.570796326794896614463458507897073960405 i": +Test "Real part of: casinh (0x1p-113 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 + 0.5 i) == 1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-23 + 0.5 i) == 1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (0x1p-23 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casinh (0x1p-23 + 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Imaginary part of: casinh (0x1p-23 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 + 0x1.000002p0 i) == 5.364668491573609633134147164031476452679e-4 + 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (0x1p-23 + 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0.5 i) == 1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1p-23 - 0.5 i) == 1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (0x1p-23 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casinh (0x1p-23 - 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Imaginary part of: casinh (0x1p-23 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0x1.000002p0 i) == 5.364668491573609633134147164031476452679e-4 - 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (0x1p-23 - 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-63 + 0.5 i) == 1.251928832280966098829878787499365228659e-19 + 5.235987755982988730771072305465838140283e-1 i": +Test "Real part of: casinh (0x1p-63 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 2.588578361325995866221775673638805081337e-10 + 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 - 0.5 i) == 1.251928832280966098829878787499365228659e-19 - 5.235987755982988730771072305465838140283e-1 i": +Test "Real part of: casinh (0x1p-63 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 2.588578361325995866221775673638805081337e-10 - 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p500 + 1.0 i) == 3.472667374605326000180332928505464606058e2 + 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (0x1p500 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p500 - 1.0 i) == 3.472667374605326000180332928505464606058e2 - 3.054936363499604682051979393213617699789e-151 i": +Test "Real part of: casinh (0x1p500 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p5000 + 1.0 i) == 3.466429049980286492395577839412341016946e3 + 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (0x1p5000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p5000 - 1.0 i) == 3.466429049980286492395577839412341016946e3 - 7.079811261048172892385615158694057552948e-1506 i": +Test "Real part of: casinh (0x1p5000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0.25 i) == 8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (1.0 + 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0.5 i) == 9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0.5 i) == 9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-10000 i) == 8.813735870195430252326093249797923090282e-1 + 6.867047849047171855399183659351043150871e-3011 i": +Test "Real part of: casinh (1.0 + 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-16385 i) == 8.813735870195430252326093249797923090282e-1 + 5.757683115456107044131264955348448954458e-4933 i": +Test "Real part of: casinh (1.0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1p500 i) == 3.472667374605326000180332928505464606058e2 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 + 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1p5000 i) == 3.466429049980286492395577839412341016946e3 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 + 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0.25 i) == 8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (1.0 - 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0.5 i) == 9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0.5 i) == 9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-10000 i) == 8.813735870195430252326093249797923090282e-1 - 6.867047849047171855399183659351043150871e-3011 i": +Test "Real part of: casinh (1.0 - 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-16385 i) == 8.813735870195430252326093249797923090282e-1 - 5.757683115456107044131264955348448954458e-4933 i": +Test "Real part of: casinh (1.0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1p500 i) == 3.472667374605326000180332928505464606058e2 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 - 0x1p500 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1p5000 i) == 3.466429049980286492395577839412341016946e3 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (1.0 - 0x1p5000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-16385 i) == 1.194763217287109304111930828519090523536 + 4.516698239814521372306784062043266700598e-4933 i": +Test "Real part of: casinh (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-16385 i) == 1.194763217287109304111930828519090523536 - 4.516698239814521372306784062043266700598e-4933 i": +Test "Real part of: casinh (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # catan -Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i) == -7.853981633974482679822974223765039144191e-1 + 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i)": double: 1 idouble: 1 -Test "Real part of: catan (-0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-16382 i) == -7.853981633974483096156608458198756729010e-1 + 1.681051571556046753131338908660876463178e-4932 i": +Test "Real part of: catan (-0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-57 i) == -7.853981633974483096156608458198756849381e-1 + 3.469446951953614188823848962783813782817e-18 i": +Test "Imaginary part of: catan (-0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-57 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-16382 i) == -7.853981633974483096156608458198756729010e-1 - 1.681051571556046753131338908660876463178e-4932 i": +Test "Real part of: catan (-0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x0.ffffffp0 + 0x1p-126 i) == -7.853981335951250337419109991749089175724e-1 + 5.877472104436064061535099214664320916184e-39 i": +Test "Real part of: catan (-0x0.ffffffp0 + 0x1p-126 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i) == -7.853981373204155542484315721351697277336e-1 + 6.103515973639646453881721999956617260502e-5 i": +Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x0.ffffffp0 - 0x1p-126 i) == -7.853981335951250337419109991749089175724e-1 - 5.877472104436064061535099214664320916184e-39 i": +Test "Real part of: catan (-0x0.ffffffp0 - 0x1p-126 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.0000000000000000000000000001p0 + 0x1p-16382 i) == -7.853981633974483096156608458198758173458e-1 + 1.681051571556046753131338908660875977540e-4932 i": +Test "Imaginary part of: catan (-0x1.0000000000000000000000000001p0 + 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.0000000000000000000000000001p0 - 0x1p-16382 i) == -7.853981633974483096156608458198758173458e-1 - 1.681051571556046753131338908660875977540e-4932 i": +Test "Imaginary part of: catan (-0x1.0000000000000000000000000001p0 - 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.0000000000000000000000000001p0 - 0x1p-57 i) == -7.853981633974483096156608458198758293829e-1 - 3.469446951953614188823848962783812780530e-18 i": +Test "Imaginary part of: catan (-0x1.0000000000000000000000000001p0 - 0x1p-57 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.0000000000001p0 - 0x1p-27 i) == -7.853981633974484345157511161499711112683e-1 - 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (-0x1.0000000000001p0 - 0x1p-27 i)": double: 1 idouble: 1 -Test "Real part of: catan (-0x1.000002p0 + 0x1p-126 i) == -7.853982230020895322927482174768220815493e-1 + 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (-0x1.000002p0 + 0x1p-126 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1.000002p0 + 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 + 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000002p0 - 0x1p-126 i) == -7.853982230020895322927482174768220815493e-1 - 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (-0x1.000002p0 - 0x1p-126 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1.000002p0 - 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i) == -1.570796326794896619231321691639751442099 + 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i) == -1.570796326794896619231321691639751442099 - 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i) == -1.570796326794896619231321691639751442097 + 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i) == -1.570796326794896619231321691639751442097 - 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.fp16383 + 0x1.fp16383 i) == -1.570796326794896619231321691639751442099 + 4.338197604015604524209906861060325938836e-4933 i": +Test "Imaginary part of: catan (-0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp16383 - 0x1.fp16383 i) == -1.570796326794896619231321691639751442099 - 4.338197604015604524209906861060325938836e-4933 i": +Test "Imaginary part of: catan (-0x1.fp16383 - 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i) == -7.853981633974483096156608458198757210493e-1 + 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i) == -7.853981633974483096156608458198757210493e-1 - 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: catan (-0x1p-13 + 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 + 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (-0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 + 1.0 i) == -7.854286809755354140031716771044626356262e-1 + 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (-0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 - 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-13 - 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Imaginary part of: catan (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 - 1.0 i) == -7.854286809755354140031716771044626356262e-1 - 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (-0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-16380 + 1.0 i) == -7.853981633974483096156608458198757210493e-1 + 5.677221982376232056781839690803195180822e3 i": +Test "Imaginary part of: catan (-0x1p-16380 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-16380 - 1.0 i) == -7.853981633974483096156608458198757210493e-1 - 5.677221982376232056781839690803195180822e3 i": +Test "Imaginary part of: catan (-0x1p-16380 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1p-33 + 0x0.ffffffffffffffffp0 i) == -7.853981631937214964185249205444919953948e-1 + 1.178350206951907026002603046195591193050e1 i": +Test "Real part of: catan (-0x1p-33 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1p-33 + 0x1.0000000000000002p0 i) == -7.853981638922134273801338071094141188767e-1 + 1.178350206951907025990405771755129268176e1 i": +Test "Real part of: catan (-0x1p-33 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1p-33 - 0x0.ffffffffffffffffp0 i) == -7.853981631937214964185249205444919953948e-1 - 1.178350206951907026002603046195591193050e1 i": +Test "Real part of: catan (-0x1p-33 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1p-33 - 0x1.0000000000000002p0 i) == -7.853981638922134273801338071094141188767e-1 - 1.178350206951907025990405771755129268176e1 i": +Test "Real part of: catan (-0x1p-33 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-54 + 1.0 i) == -7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (-0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-54 - 1.0 i) == -7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (-0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-57 + 1.0 i) == -7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (-0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-57 - 1.0 i) == -7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (-0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 + 0x1p-13 i) == -7.853981671227386080775748393881580082970e-1 + 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (-1.0 + 0x1p-13 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (-1.0 - 0x1p-13 i) == -7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (-1.0 - 0x1p-13 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (0.75 + 1.25 i) == 1.10714871779409050301706546017853704 + 0.549306144334054845697622618461262852 i": +Test "Imaginary part of: catan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i) == 7.853981633974482679822974223765039144191e-1 + 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i)": double: 1 idouble: 1 -Test "Real part of: catan (0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-16382 i) == 7.853981633974483096156608458198756729010e-1 + 1.681051571556046753131338908660876463178e-4932 i": +Test "Real part of: catan (0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-57 i) == 7.853981633974483096156608458198756849381e-1 + 3.469446951953614188823848962783813782817e-18 i": +Test "Imaginary part of: catan (0x0.ffffffffffffffffffffffffffff8p0 + 0x1p-57 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-16382 i) == 7.853981633974483096156608458198756729010e-1 - 1.681051571556046753131338908660876463178e-4932 i": +Test "Real part of: catan (0x0.ffffffffffffffffffffffffffff8p0 - 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x0.ffffffp0 + 0x1p-126 i) == 7.853981335951250337419109991749089175724e-1 + 5.877472104436064061535099214664320916184e-39 i": +Test "Real part of: catan (0x0.ffffffp0 + 0x1p-126 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i) == 7.853981373204155542484315721351697277336e-1 + 6.103515973639646453881721999956617260502e-5 i": +Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x0.ffffffp0 - 0x1p-126 i) == 7.853981335951250337419109991749089175724e-1 - 5.877472104436064061535099214664320916184e-39 i": +Test "Real part of: catan (0x0.ffffffp0 - 0x1p-126 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.0000000000000000000000000001p0 + 0x1p-16382 i) == 7.853981633974483096156608458198758173458e-1 + 1.681051571556046753131338908660875977540e-4932 i": +Test "Imaginary part of: catan (0x1.0000000000000000000000000001p0 + 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.0000000000000000000000000001p0 - 0x1p-16382 i) == 7.853981633974483096156608458198758173458e-1 - 1.681051571556046753131338908660875977540e-4932 i": +Test "Imaginary part of: catan (0x1.0000000000000000000000000001p0 - 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.0000000000000000000000000001p0 - 0x1p-57 i) == 7.853981633974483096156608458198758293829e-1 - 3.469446951953614188823848962783812780530e-18 i": +Test "Imaginary part of: catan (0x1.0000000000000000000000000001p0 - 0x1p-57 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.0000000000001p0 - 0x1p-27 i) == 7.853981633974484345157511161499711112683e-1 - 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (0x1.0000000000001p0 - 0x1p-27 i)": double: 1 idouble: 1 -Test "Real part of: catan (0x1.000002p0 + 0x1p-126 i) == 7.853982230020895322927482174768220815493e-1 + 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (0x1.000002p0 + 0x1p-126 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1.000002p0 + 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 + 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1.000002p0 - 0x1p-126 i) == 7.853982230020895322927482174768220815493e-1 - 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (0x1.000002p0 - 0x1p-126 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1.000002p0 - 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i) == 1.570796326794896619231321691639751442099 + 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i) == 1.570796326794896619231321691639751442099 - 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i) == 1.570796326794896619231321691639751442097 + 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i) == 1.570796326794896619231321691639751442097 - 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.fp16383 + 0x1.fp16383 i) == 1.570796326794896619231321691639751442099 + 4.338197604015604524209906861060325938836e-4933 i": +Test "Imaginary part of: catan (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp16383 - 0x1.fp16383 i) == 1.570796326794896619231321691639751442099 - 4.338197604015604524209906861060325938836e-4933 i": +Test "Imaginary part of: catan (0x1.fp16383 - 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-1020 + 1.0 i) == 7.853981633974483096156608458198757210493e-1 + 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (0x1p-1020 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1p-1020 - 1.0 i) == 7.853981633974483096156608458198757210493e-1 - 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (0x1p-1020 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: catan (0x1p-13 + 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 + 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 + 1.0 i) == 7.854286809755354140031716771044626356262e-1 + 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 - 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-13 - 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Imaginary part of: catan (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 - 1.0 i) == 7.854286809755354140031716771044626356262e-1 - 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-16380 + 1.0 i) == 7.853981633974483096156608458198757210493e-1 + 5.677221982376232056781839690803195180822e3 i": +Test "Imaginary part of: catan (0x1p-16380 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-16380 - 1.0 i) == 7.853981633974483096156608458198757210493e-1 - 5.677221982376232056781839690803195180822e3 i": +Test "Imaginary part of: catan (0x1p-16380 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1p-33 + 0x0.ffffffffffffffffp0 i) == 7.853981631937214964185249205444919953948e-1 + 1.178350206951907026002603046195591193050e1 i": +Test "Real part of: catan (0x1p-33 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1p-33 + 0x1.0000000000000002p0 i) == 7.853981638922134273801338071094141188767e-1 + 1.178350206951907025990405771755129268176e1 i": +Test "Real part of: catan (0x1p-33 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1p-33 - 0x0.ffffffffffffffffp0 i) == 7.853981631937214964185249205444919953948e-1 - 1.178350206951907026002603046195591193050e1 i": +Test "Real part of: catan (0x1p-33 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1p-33 - 0x1.0000000000000002p0 i) == 7.853981638922134273801338071094141188767e-1 - 1.178350206951907025990405771755129268176e1 i": +Test "Real part of: catan (0x1p-33 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-54 + 1.0 i) == 7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-54 - 1.0 i) == 7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-57 + 1.0 i) == 7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-57 - 1.0 i) == 7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 + 0x1p-13 i) == 7.853981671227386080775748393881580082970e-1 + 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (1.0 + 0x1p-13 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catan (1.0 - 0x1p-13 i) == 7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (1.0 - 0x1p-13 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # catanh -Test "Imaginary part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-33 i) == -1.178350206951907026002603046195591193050e1 + 7.853981631937214964185249205444919953948e-1 i": +Test "Imaginary part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-33 i) == -1.178350206951907026002603046195591193050e1 - 7.853981631937214964185249205444919953948e-1 i": +Test "Imaginary part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1.0000000000000002p0 + 0x1p-33 i) == -1.178350206951907025990405771755129268176e1 + 7.853981638922134273801338071094141188767e-1 i": +Test "Imaginary part of: catanh (-0x1.0000000000000002p0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1.0000000000000002p0 - 0x1p-33 i) == -1.178350206951907025990405771755129268176e1 - 7.853981638922134273801338071094141188767e-1 i": +Test "Imaginary part of: catanh (-0x1.0000000000000002p0 - 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.000002p0 + 0x1p-13 i) == -4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Real part of: catanh (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1.000002p0 + 0x1p-13 i) == -4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1.000002p0 - 0x1p-13 i) == -4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Real part of: catanh (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1.000002p0 - 0x1p-13 i) == -4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i) == -2.871063043235098558826106732041811695767e-309 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i) == -2.871063043235098558826106732041811695767e-309 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i) == -1.516766904286822590927401983512575068153e-39 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i) == -1.516766904286822590927401983512575068153e-39 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1.fp16383 + 0x1.fp16383 i) == -4.338197604015604524209906861060325938836e-4933 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp16383 - 0x1.fp16383 i) == -4.338197604015604524209906861060325938836e-4933 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp16383 - 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-126 + 0x0.ffffffp0 i) == -5.877472104436064061535099214664320916184e-39 + 7.853981335951250337419109991749089175724e-1 i": +Test "Imaginary part of: catanh (-0x1p-126 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-126 + 0x1.000002p0 i) == -5.877471053462247139383742414506671233336e-39 + 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (-0x1p-126 + 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-126 - 0x0.ffffffp0 i) == -5.877472104436064061535099214664320916184e-39 - 7.853981335951250337419109991749089175724e-1 i": +Test "Imaginary part of: catanh (-0x1p-126 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-126 - 0x1.000002p0 i) == -5.877471053462247139383742414506671233336e-39 - 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (-0x1p-126 - 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-13 + 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-13 + 1.0 i) == -6.103515609841754902688560615027452023669e-5 + 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-13 - 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-13 - 1.0 i) == -6.103515609841754902688560615027452023669e-5 - 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-16382 + 0x0.ffffffffffffffffffffffffffff8p0 i) == -1.681051571556046753131338908660876463178e-4932 + 7.853981633974483096156608458198756729010e-1 i": +Test "Imaginary part of: catanh (-0x1p-16382 + 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-16382 + 0x1.0000000000000000000000000001p0 i) == -1.681051571556046753131338908660875977540e-4932 + 7.853981633974483096156608458198758173458e-1 i": +Test "Real part of: catanh (-0x1p-16382 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-16382 - 0x0.ffffffffffffffffffffffffffff8p0 i) == -1.681051571556046753131338908660876463178e-4932 - 7.853981633974483096156608458198756729010e-1 i": +Test "Imaginary part of: catanh (-0x1p-16382 - 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-16382 - 0x1.0000000000000000000000000001p0 i) == -1.681051571556046753131338908660875977540e-4932 - 7.853981633974483096156608458198758173458e-1 i": +Test "Real part of: catanh (-0x1p-16382 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-27 + 0x1.0000000000001p0 i) == -3.725290298461913200853528590596263270474e-9 + 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (-0x1p-27 + 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1p-27 - 0x1.0000000000001p0 i) == -3.725290298461913200853528590596263270474e-9 - 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (-0x1p-27 - 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (-0x1p-57 + 0x1.0000000000000000000000000001p0 i) == -3.469446951953614188823848962783812780530e-18 + 7.853981633974483096156608458198758293829e-1 i": +Test "Real part of: catanh (-0x1p-57 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-57 - 0x1.0000000000000000000000000001p0 i) == -3.469446951953614188823848962783812780530e-18 - 7.853981633974483096156608458198758293829e-1 i": +Test "Real part of: catanh (-0x1p-57 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 + 0x1p-1020 i) == -3.538516356758520804574969980043991380025e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-13 i) == -4.852030264850939738801379894163661227127 + 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 + 0x1p-16380 i) == -5.677221982376232056781839690803195180822e3 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-16380 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 + 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 + 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-1020 i) == -3.538516356758520804574969980043991380025e2 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-13 i) == -4.852030264850939738801379894163661227127 - 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-16380 i) == -5.677221982376232056781839690803195180822e3 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-16380 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 - 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Imaginary part of: catanh (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-33 i) == 1.178350206951907026002603046195591193050e1 + 7.853981631937214964185249205444919953948e-1 i": +Test "Imaginary part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-33 i) == 1.178350206951907026002603046195591193050e1 - 7.853981631937214964185249205444919953948e-1 i": +Test "Imaginary part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1.0000000000000002p0 + 0x1p-33 i) == 1.178350206951907025990405771755129268176e1 + 7.853981638922134273801338071094141188767e-1 i": +Test "Imaginary part of: catanh (0x1.0000000000000002p0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1.0000000000000002p0 - 0x1p-33 i) == 1.178350206951907025990405771755129268176e1 - 7.853981638922134273801338071094141188767e-1 i": +Test "Imaginary part of: catanh (0x1.0000000000000002p0 - 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1.000002p0 + 0x1p-13 i) == 4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1.000002p0 - 0x1p-13 i) == 4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i) == 2.871063043235098558826106732041811695767e-309 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i) == 2.871063043235098558826106732041811695767e-309 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i) == 1.516766904286822590927401983512575068153e-39 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i) == 1.516766904286822590927401983512575068153e-39 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1.fp16383 + 0x1.fp16383 i) == 4.338197604015604524209906861060325938836e-4933 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp16383 - 0x1.fp16383 i) == 4.338197604015604524209906861060325938836e-4933 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp16383 - 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-126 + 0x0.ffffffp0 i) == 5.877472104436064061535099214664320916184e-39 + 7.853981335951250337419109991749089175724e-1 i": +Test "Imaginary part of: catanh (0x1p-126 + 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-126 + 0x1.000002p0 i) == 5.877471053462247139383742414506671233336e-39 + 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (0x1p-126 + 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-126 - 0x0.ffffffp0 i) == 5.877472104436064061535099214664320916184e-39 - 7.853981335951250337419109991749089175724e-1 i": +Test "Imaginary part of: catanh (0x1p-126 - 0x0.ffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-126 - 0x1.000002p0 i) == 5.877471053462247139383742414506671233336e-39 - 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (0x1p-126 - 0x1.000002p0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i) == 6.103515973639646453881721999956617260502e-5 + 7.853981373204155542484315721351697277336e-1 i": +Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-13 + 0x1.000002p0 i) == 6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 + 1.0 i) == 6.103515609841754902688560615027452023669e-5 + 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (0x1p-13 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i) == 6.103515973639646453881721999956617260502e-5 - 7.853981373204155542484315721351697277336e-1 i": +Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-13 - 0x1.000002p0 i) == 6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 - 1.0 i) == 6.103515609841754902688560615027452023669e-5 - 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (0x1p-13 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-16382 + 0x0.ffffffffffffffffffffffffffff8p0 i) == 1.681051571556046753131338908660876463178e-4932 + 7.853981633974483096156608458198756729010e-1 i": +Test "Imaginary part of: catanh (0x1p-16382 + 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-16382 + 0x1.0000000000000000000000000001p0 i) == 1.681051571556046753131338908660875977540e-4932 + 7.853981633974483096156608458198758173458e-1 i": +Test "Real part of: catanh (0x1p-16382 + 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-16382 - 0x0.ffffffffffffffffffffffffffff8p0 i) == 1.681051571556046753131338908660876463178e-4932 - 7.853981633974483096156608458198756729010e-1 i": +Test "Imaginary part of: catanh (0x1p-16382 - 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-16382 - 0x1.0000000000000000000000000001p0 i) == 1.681051571556046753131338908660875977540e-4932 - 7.853981633974483096156608458198758173458e-1 i": +Test "Real part of: catanh (0x1p-16382 - 0x1.0000000000000000000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i) == 3.725290298461914441624447420137706700965e-9 + 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i) == 3.725290298461914441624447420137706700965e-9 - 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1p-57 + 0x0.ffffffffffffffffffffffffffff8p0 i) == 3.469446951953614188823848962783813782817e-18 + 7.853981633974483096156608458198756849381e-1 i": +Test "Real part of: catanh (0x1p-57 + 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-57 - 0x0.ffffffffffffffffffffffffffff8p0 i) == 3.469446951953614188823848962783813782817e-18 - 7.853981633974483096156608458198756849381e-1 i": +Test "Real part of: catanh (0x1p-57 - 0x0.ffffffffffffffffffffffffffff8p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 + 0x1p-1020 i) == 3.538516356758520804574969980043991380025e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-13 i) == 4.852030264850939738801379894163661227127 + 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 + 0x1p-16380 i) == 5.677221982376232056781839690803195180822e3 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-16380 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 + 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 + 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-1020 i) == 3.538516356758520804574969980043991380025e2 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-1020 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-13 i) == 4.852030264850939738801379894163661227127 - 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-16380 i) == 5.677221982376232056781839690803195180822e3 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-16380 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 - 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-57 i)": float: 1 ifloat: 1 # cbrt -Test "cbrt (-0.001) == -0.1": +Test "cbrt (-0.001)": ildouble: 1 ldouble: 1 -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 11357.25 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (-0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 11357.25 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (-0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (-0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Real part of: ccos (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 + 11357.25 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 11357.25 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccos (0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccos (0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0x1p-16434 + 22730 i) == inf - 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: ccos (0x1p-16434 + 22730 i)": ildouble: 1 ldouble: 1 # ccosh -Test "Imaginary part of: ccosh (-11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (-11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (-11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (-89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: ccosh (11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (22730 + 0x1p-16434 i) == inf + 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: ccosh (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: ccosh (89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cexp -Test "Imaginary part of: cexp (-10000 + 0x1p16383 i) == 1.045876464564882298442774542991176546722e-4343 + 4.421154026488516836023811173959413420548e-4344 i": +Test "Imaginary part of: cexp (-10000 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Real part of: cexp (-2.0 - 3.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-720 + 0.75 i) == 1.486960657116368433685753325516638551722e-313 + 1.385247284245720590980701226843815229385e-313 i": +Test "Imaginary part of: cexp (-720 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (22730 + 0x1p-16434 i) == inf + 2.435706297811211974162115164702304105374e4924 i": +Test "Imaginary part of: cexp (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16494 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16494 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16494 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16494 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16494 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16494 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Real part of: clog (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Imaginary part of: clog (0x1.000566p0 + 0x1.234p-10 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i) == 11356.83823118610934184548269774874545400 + pi/4 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16494 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16494 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16494 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 3.2047474274603604594851472963586149973093e-29 + 1.4422922682185099608731642353544207976604 i": +Test "Imaginary part of: clog (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16494 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16494 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16494 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16494 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i) == -1.1931267660846218205882675852805793644095e-36 + 1.2402109774337032400594953899784058127412 i": +Test "Imaginary part of: clog (0x298c62cb546588a7p-63 + 0x7911b1dfcc4ecdaep-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2ede88p-23 + 0x771c3fp-23 i) == -4.4764192352906350039050902870893173560494e-13 + 1.1959106857549200806818600493552847793381 i": +Test "Imaginary part of: clog (0x2ede88p-23 + 0x771c3fp-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i) == -1.0509738482436128031927971874674370984602e-45 + 1.0509191467640012308402149909370784281448 i": +Test "Imaginary part of: clog (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i) == -5.2000108498455368032511404449795741611813e-32 + 1.5288921536982513453421343495466824420259 i": +Test "Imaginary part of: clog (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 8.3076914081087805757422664530653247447136e-30 + 1.2072712126771536614482822173033535043206 i": +Test "Imaginary part of: clog (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x659feap-24 + 0xeaf6f9p-24 i) == 3.7303493627403868207597214252239749960738e-14 + 1.1625816408046866464773042283673653469061 i": +Test "Imaginary part of: clog (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6771f22c64ed551b857c128b4cp-105 + 0x1f570e7a13cc3cf2f44fd793ea1p-105 i) == -1.4281333889622737316199756373421183559948e-62 + 1.3673546561165378090903506783353927980633 i": +Test "Imaginary part of: clog (0x6771f22c64ed551b857c128b4cp-105 + 0x1f570e7a13cc3cf2f44fd793ea1p-105 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 2.4244570985709679851855191080208817099132e-37 + 1.1393074519572050614551047548718495655972 i": +Test "Imaginary part of: clog (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i) == -9.7375017988218644730510244778042114638107e-30 + 0.9790637929494922564724108399524154766631 i": +Test "Real part of: clog (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x9b57bp-20 + 0xcb7b4p-20 i) == -3.9563019528687610863490232935890272740908e-11 + 0.9187593477446338910857133065497364950682 i": +Test "Imaginary part of: clog (0x9b57bp-20 + 0xcb7b4p-20 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i) == 4.6017338806965821566734340588575402712716e-67 + 1.3547418904611758959096647942223384691728 i": +Test "Imaginary part of: clog (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i) == 6.6255694866654064502633121109394710807528e-66 + 1.0526409614996288387567810726095850312049 i": +Test "Imaginary part of: clog (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 5.3718272201930019901317065495843842735179e-26 + 1.0503831592447830576186444373011142397404 i": +Test "Imaginary part of: clog (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Real part of: clog10 (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Real part of: clog10 (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Imaginary part of: clog10 (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i) == 4.285899851347756186652871946325962330640e-19 + 4.611541215247321502041995872887317363241e-302 i": +Test "Real part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i) == 4.285899851347756186652871946325962330640e-19 + 4.611541215247321502041995872887317363241e-302 i": +Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-60 i) == 4.285899851347756188767674032946882584784e-19 + 4.285899850759344225805480528847018395861e-19 i": +Test "Imaginary part of: clog10 (0x1.00000000000000123456789abcp0 + 0x1.23456789p-60 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Real part of: clog10 (0x1.234566p-50 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Real part of: clog10 (0x1.234566p-60 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 308.4052305577487344482591243175787477115 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i) == 4932.212175672014259683102930239951947672 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i) == 4932.112944269463028900262609694408579449 + 0.2069271710841128115912940666587802677383 i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1415bcaf2105940d49a636e98ae59p-115 + 0x7e6a150adfcd1b0921d44b31f40f4p-115 i) == 1.1288799405048268615023706955013387413519e-67 + 0.6137587762850841972073301550420510507903 i": +Test "Real part of: clog10 (0x1415bcaf2105940d49a636e98ae59p-115 + 0x7e6a150adfcd1b0921d44b31f40f4p-115 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i) == 4.4163015461643576961232672330852798804976e-31 + 0.3564851427422832755956993418877523303529 i": +Test "Imaginary part of: clog10 (0x15cfbd1990d1ffp-53 + 0x176a3973e09a9ap-53 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Real part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i) == -1.5221162575729652613635150540947625639689e-57 + 0.5795934880811949230121092882659698986043 i": +Test "Imaginary part of: clog10 (0x1df515eb171a808b9e400266p-95 + 0x7c71eb0cd4688dfe98581c77p-95 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i) == -322.8546703496198318667349645920187712089 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i) == -4.5643214291682663316715446865040356750881e-46 + 0.4564083863660793840592614609053162690362 i": +Test "Imaginary part of: clog10 (0x3f96469050f650869c2p-75 + 0x6f16b2c9c8b05988335p-75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i) == 2.7822833698845776001753149807484078521508e-37 + 0.3992725998539071066769046272515417679815 i": +Test "Real part of: clog10 (0x4d9c37e2b5cb4533p-63 + 0x65c98be2385a042ep-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i) == -2.2583360179249556400630343805573865814771e-32 + 0.6639894257763289307423302343317622430835 i": +Test "Real part of: clog10 (0x55cb6d0c83af5p-55 + 0x7fe33c0c7c4e90p-55 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i) == -1.0146400362652473358437501879334790111898e-37 + 0.5149047982335273098246594109614460842099 i": +Test "Real part of: clog10 (0x602fd5037c4792efp-64 + 0xed3e2086dcca80b8p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i) == 1.8804859395820231849002915747252695375405e-63 + 0.6404513901551516189871978418046651877394 i": +Test "Real part of: clog10 (0x6241ef0da53f539f02fad67dabp-106 + 0x3fb46641182f7efd9caa769dac0p-106 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Real part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 1.0529283395205396881397407610630442563938e-37 + 0.4947949395762683446121140513971996916447 i": +Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i) == 1.9985076315737626043096596036300177494613e-67 + 0.5883569274304683249184005177865521205198 i": +Test "Real part of: clog10 (0xdb85c467ee2aadd5f425fe0f4b8dp-114 + 0x3e83162a0f95f1dcbf97dddf410eap-114 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i) == 2.8774482675253468630312378575186855052697e-66 + 0.4571561610046221605554903008571429975493 i": +Test "Imaginary part of: clog10 (0xfd95243681c055c2632286921092p-113 + 0x1bccabcd29ca2152860ec29e34ef7p-113 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos -Test "cos (0x1p+120) == -9.25879022854837867303861764107414946730833e-01": +Test "cos (0x1p+120)": float: 1 ifloat: 1 -Test "cos (0x1p+127) == 7.81914638714960072263910298466369236613162e-01": +Test "cos (0x1p+127)": float: 1 ifloat: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 @@ -6803,194 +6803,194 @@ ildouble: 1 ldouble: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 -Test "cos_downward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_downward (10)": ildouble: 1 ldouble: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_downward (6)": ildouble: 1 ldouble: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 # cos_towardzero -Test "cos_towardzero (10) == -0.8390715290764524522588639478240648345199": +Test "cos_towardzero (10)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (6) == 0.9601702866503660205456522979229244054519": +Test "cos_towardzero (6)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # cos_upward -Test "cos_upward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_upward (1)": ildouble: 1 ldouble: 1 -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 -Test "cos_upward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_upward (4)": ildouble: 1 ldouble: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_tonearest -Test "cosh_tonearest (22) == 1792456423.065795780980053377632656584997": +Test "cosh_tonearest (22)": ildouble: 1 ldouble: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_upward -Test "cosh_upward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_upward (22)": ildouble: 1 ldouble: 1 -Test "cosh_upward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_upward (23)": ildouble: 1 ldouble: 1 -Test "cosh_upward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_upward (24)": ildouble: 1 ldouble: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 4 ldouble: 4 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 ildouble: 11 ldouble: 11 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 2 ldouble: 2 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 @@ -6999,941 +6999,941 @@ ildouble: 1 ldouble: 1 # csin -Test "Real part of: csin (-0.75 + 11357.25 i) == -8.385498349388321535962327491346664141020e4931 + 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (-0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 11357.25 i) == -8.385498349388321535962327491346664141020e4931 - 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (-0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (-0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (-2 - 3 i) == -9.15449914691142957346729954460983256 + 4.16890695996656435075481305885375484 i": +Test "Imaginary part of: csin (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Real part of: csin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 11357.25 i) == 8.385498349388321535962327491346664141020e4931 + 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (0.75 + 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 + 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 11357.25 i) == 8.385498349388321535962327491346664141020e4931 - 9.001213196851067077465606717616495588201e4931 i": +Test "Real part of: csin (0.75 - 11357.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Imaginary part of: csin (0.75 - 89.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 -Test "Real part of: csin (0x1p-16434 + 22730 i) == 1.217853148905605987081057582351152052687e4924 + inf i": +Test "Real part of: csin (0x1p-16434 + 22730 i)": ildouble: 1 ldouble: 1 # csinh -Test "Imaginary part of: csinh (-11357.25 + 0.75 i) == -9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (-11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-11357.25 - 0.75 i) == -9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (-11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Real part of: csinh (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (-89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (11357.25 + 0.75 i) == 9.001213196851067077465606717616495588201e4931 + 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (11357.25 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (11357.25 - 0.75 i) == 9.001213196851067077465606717616495588201e4931 - 8.385498349388321535962327491346664141020e4931 i": +Test "Imaginary part of: csinh (11357.25 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (22730 + 0x1p-16434 i) == inf + 1.217853148905605987081057582351152052687e4924 i": +Test "Imaginary part of: csinh (22730 + 0x1p-16434 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Real part of: csinh (89.5 - 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # csqrt -Test "Real part of: csqrt (-0x1.0000000000000000000000000001p-16382 - 0x1.0000000000000000000000000001p-16382 i) == 8.344545284118961663847948339519226074126e-2467 - 2.014551439675644900022606748976158925145e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000000000000000001p-16382 - 0x1.0000000000000000000000000001p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i) == 6.788430486774966350907249113759995429568e-155 - 1.638872094839911521020410942677082920935e-154 i": +Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0.75 + 1.25 i) == 1.05065169626078392338656675760808326 + 0.594868882070379067881984030639932657 i": +Test "Imaginary part of: csqrt (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i) == 2.014551439675644900022606748976158925145e-2466 + 8.344545284118961663847948339519226074126e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000000000000000001p-16382 + 0x1.0000000000000000000000000001p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i) == 1.638872094839911521020410942677082920935e-154 + 6.788430486774966350907249113759995429568e-155 i": +Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Real part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1p+16383 i) == 1.106698967236475180613254276996359485630e+2466 + 2.687568007603946993388538156299100955642e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-16440 + 0x1p-16441 i) == 3.514690655930285351254618340783294558136e-2475 + 8.297059146828716918029689466551384219370e-2476 i": +Test "Imaginary part of: csqrt (0x1p-16440 + 0x1p-16441 i)": ildouble: 1 ldouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Real part of: ctan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 -Test "Imaginary part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Imaginary part of: ctan (0x1p1023 + 1 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Real part of: ctan (0x1p127 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Real part of: ctan (0x1p16383 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0x1p16383 + 1 i) == 0.1608598776370396607204448234354670036772 + 0.8133818522051542536316746743877629761488 i": +Test "Imaginary part of: ctan (0x1p16383 + 1 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 355 i) == 8.140551093483276762350406321792653551513e-309 + 1.0 i": +Test "Real part of: ctan (1 + 355 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 365 i) == 1.677892637497921890115075995898773550884e-317 + 1.0 i": +Test "Real part of: ctan (1 + 365 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 45 i) == 1.490158918874345552942703234806348520895e-39 + 1.000000000000000000000000000000000000001 i": +Test "Real part of: ctan (1 + 45 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan (1 + 47 i) == 2.729321264492904590777293425576722354636e-41 + 1.0 i": +Test "Real part of: ctan (1 + 47 i)": ildouble: 1 ldouble: 1 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 # ctan_tonearest -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 ifloat: 2 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Real part of: ctanh (1 + 0x1p1023 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Imaginary part of: ctanh (1 + 0x1p127 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Real part of: ctanh (1 + 0x1p16383 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (1 + 0x1p16383 i) == 0.8133818522051542536316746743877629761488 + 0.1608598776370396607204448234354670036772 i": +Test "Imaginary part of: ctanh (1 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (355 + 1 i) == 1.0 + 8.140551093483276762350406321792653551513e-309 i": +Test "Imaginary part of: ctanh (355 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (365 + 1 i) == 1.0 + 1.677892637497921890115075995898773550884e-317 i": +Test "Imaginary part of: ctanh (365 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (45 + 1 i) == 1.000000000000000000000000000000000000001 + 1.490158918874345552942703234806348520895e-39 i": +Test "Imaginary part of: ctanh (45 + 1 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh (47 + 1 i) == 1.0 + 2.729321264492904590777293425576722354636e-41 i": +Test "Imaginary part of: ctanh (47 + 1 i)": ildouble: 1 ldouble: 1 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 4 ldouble: 4 -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 2 ldouble: 2 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_upward -Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "erfc (0x1.ffffc8p+2) == 1.122671365033056305522366683719541099329e-29": +Test "erfc (0x1.ffffc8p+2)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (27.0) == 0.523704892378925568501606768284954709e-318": +Test "erfc (27.0)": ildouble: 1 ldouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "exp10 (0.75) == 5.62341325190349080394951039776481231": +Test "exp10 (0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 6 float: 2 idouble: 6 ifloat: 2 ildouble: 1 ldouble: 1 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 -Test "exp10 (4932) == 1.0e4932": +Test "exp10 (4932)": ildouble: 1 ldouble: 1 # exp2 -Test "exp2 (100.5) == 1.792728671193156477399422023278661496394e+30": +Test "exp2 (100.5)": ildouble: 1 ldouble: 1 # exp_downward -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_towardzero -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # expm1 -Test "expm1 (-79.0) == -0.9999999999999999999999999999999999509391": +Test "expm1 (-79.0)": ildouble: 1 ldouble: 1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # gamma -Test "gamma (-0.5) == log(2*sqrt(pi))": +Test "gamma (-0.5)": ildouble: 1 ldouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-0x1.001000001p+593) == -3.927269966354206207832593635798954916263e-90": +Test "j0 (-0x1.001000001p+593)": ildouble: 1 ldouble: 1 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j0 (0x1p1023) == -1.5665258060609012834424478437196679802783e-155": +Test "j0 (0x1p1023)": ildouble: 1 ldouble: 1 -Test "j0 (0x1p16383) == 9.5859502826270374691362975419147645151233e-2467": +Test "j0 (0x1p16383)": ildouble: 2 ldouble: 2 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # j1 -Test "j1 (-1.0) == -0.440050585744933515959682203718914913": +Test "j1 (-1.0)": ildouble: 1 ldouble: 1 -Test "j1 (0.75) == 0.349243602174862192523281016426251335": +Test "j1 (0.75)": ildouble: 1 ldouble: 1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (0x1p1023) == 8.2687542933709649327986678723012001545638e-155": +Test "j1 (0x1p1023)": ildouble: 1 ldouble: 1 -Test "j1 (0x1p16382) == 8.0839224448726336195866026476176740513439e-2467": +Test "j1 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "j1 (0x1p16383) == -3.8895531955766020648617743624167352352217e-2467": +Test "j1 (0x1p16383)": ildouble: 2 ldouble: 2 -Test "j1 (1.0) == 0.440050585744933515959682203718914913": +Test "j1 (1.0)": ildouble: 1 ldouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (1, -1.0) == -0.440050585744933515959682203718914913": +Test "jn (1, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (1, 0.75) == 0.349243602174862192523281016426251335": +Test "jn (1, 0.75)": ildouble: 1 ldouble: 1 -Test "jn (1, 1.0) == 0.440050585744933515959682203718914913": +Test "jn (1, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 ildouble: 4 ldouble: 4 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 2 ldouble: 2 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": float: 1 ifloat: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 5 ldouble: 5 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 ildouble: 3 ldouble: 3 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 ildouble: 8 ldouble: 8 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 @@ -7942,17 +7942,17 @@ ildouble: 3 ldouble: 3 # lgamma -Test "lgamma (-0.5) == log(2*sqrt(pi))": +Test "lgamma (-0.5)": ildouble: 1 ldouble: 1 -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -7961,1278 +7961,1278 @@ ildouble: 1 ldouble: 1 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # log2 -Test "log2 (0.75) == -.415037499278843818546261056052183492": +Test "log2 (0.75)": ildouble: 1 ldouble: 1 # pow -Test "pow (0x0.fffffffffffff8p0, -0x1.23456789abcdfp62) == 9.8826311568054561811190162420900667121992e+252": +Test "pow (0x0.fffffffffffff8p0, -0x1.23456789abcdfp62)": ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (10.0, -4930.0) == 1e-4930": +Test "pow (10.0, -4930.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4929.0) == 1e4929": +Test "pow (10.0, 4929.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4930.0) == 1e4930": +Test "pow (10.0, 4930.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4931.0) == 1e4931": +Test "pow (10.0, 4931.0)": ildouble: 1 ldouble: 1 -Test "pow (10.0, 4932.0) == 1e4932": +Test "pow (10.0, 4932.0)": ildouble: 1 ldouble: 1 -Test "pow (1e4932, 0.75) == 1e3699": +Test "pow (1e4932, 0.75)": ildouble: 1 ldouble: 1 # pow_downward -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 # pow_towardzero -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_downward -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 -Test "sin_downward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_downward (2)": ildouble: 1 ldouble: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_downward (4)": ildouble: 1 ldouble: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 -Test "sin_downward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_downward (8)": ildouble: 1 ldouble: 1 -Test "sin_downward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_downward (9)": ildouble: 1 ldouble: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 -Test "sin_tonearest (3) == 0.1411200080598672221007448028081102798469": +Test "sin_tonearest (3)": ildouble: 1 ldouble: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (2) == 0.9092974268256816953960198659117448427023": +Test "sin_towardzero (2)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (3) == 0.1411200080598672221007448028081102798469": +Test "sin_towardzero (3)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (8) == 0.9893582466233817778081235982452886721164": +Test "sin_towardzero (8)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_upward (10)": ildouble: 1 ldouble: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 -Test "sin_upward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_upward (3)": ildouble: 1 ldouble: 1 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 -Test "sin_upward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_upward (6)": ildouble: 1 ldouble: 1 -Test "sin_upward (7) == 0.6569865987187890903969990915936351779369": +Test "sin_upward (7)": ildouble: 1 ldouble: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0x1p+120, &sin_res, &cos_res) puts -9.25879022854837867303861764107414946730833e-01 in cos_res": +Test "sincos (0x1p+120) extra output 2": float: 1 ifloat: 1 -Test "sincos (0x1p+127, &sin_res, &cos_res) puts 7.81914638714960072263910298466369236613162e-01 in cos_res": +Test "sincos (0x1p+127) extra output 2": float: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": -double: 1 -idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 2": +double: 1 +idouble: 1 +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 # sinh_upward -Test "sinh_upward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_upward (22)": ildouble: 1 ldouble: 1 -Test "sinh_upward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_upward (23)": ildouble: 1 ldouble: 1 -Test "sinh_upward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_upward (24)": ildouble: 1 ldouble: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_towardzero -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (6) == -0.2910061913847491570536995888681755428312": +Test "tan_towardzero (6)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": float: 1 ifloat: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_upward (2)": ildouble: 1 ldouble: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (4) == 1.1578212823495775831373424182673239231198": +Test "tan_upward (4)": ildouble: 1 ldouble: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_upward (6)": ildouble: 1 ldouble: 1 -Test "tan_upward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_upward (9)": ildouble: 1 ldouble: 1 # tanh -Test "tanh (-0.75) == -0.635148952387287319214434357312496495": +Test "tanh (-0.75)": ildouble: 1 ldouble: 1 -Test "tanh (-1.0) == -0.7615941559557648881194582826047935904": +Test "tanh (-1.0)": ildouble: 1 ldouble: 1 -Test "tanh (0.75) == 0.635148952387287319214434357312496495": +Test "tanh (0.75)": ildouble: 1 ldouble: 1 -Test "tanh (1.0) == 0.7615941559557648881194582826047935904": +Test "tanh (1.0)": ildouble: 1 ldouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x0.fffffffffffff8p0) == -9.0071992547409924227843350984672961392521e+15": +Test "tgamma (-0x0.fffffffffffff8p0)": double: 1 idouble: 1 -Test "tgamma (-0x0.ffffffffffffffffffffffffffff8p0) == -1.0384593717069655257060992658440192422784e+34": +Test "tgamma (-0x0.ffffffffffffffffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x0.ffffffp0) == -1.6777216422784419250710305882992376932423e+07": +Test "tgamma (-0x0.ffffffp0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.0000000000000002p0) == 9.2233720368547758075772156649015328607596e+18": +Test "tgamma (-0x1.0000000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.0000000000001p0) == 4.5035996273704955772156649015331740980405e+15": +Test "tgamma (-0x1.0000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.000002p0) == 8.3886075772158332060084424806449513922858e+06": +Test "tgamma (-0x1.000002p0)": double: 2 idouble: 2 -Test "tgamma (-0x1.0a32a2p+5) == 1.8125267978155035272941154746083439329912e-37": +Test "tgamma (-0x1.0a32a2p+5)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "tgamma (-0x1.5800000080001p+7) == -3.1439271448823567326093363350637118195240e-304": +Test "tgamma (-0x1.5800000080001p+7)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.fffffffffffffffep0) == 4.6116860184273879044613921675492335697983e+18": +Test "tgamma (-0x1.fffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.fffffffffffffp0) == 2.2517998136852484613921675492337776673289e+15": +Test "tgamma (-0x1.fffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x13.ffffep0) == 2.1550026214525536756224040483579183652119e-13": +Test "tgamma (-0x13.ffffep0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x13.ffffffffffffffep0) == 2.3694367893405502075347562184931828448654e-01": +Test "tgamma (-0x13.ffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x13.fffffffffffffffffffffffff8p0) == 1.0420893204640670202556853709074896123293e+12": +Test "tgamma (-0x13.fffffffffffffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x13.ffffffffffffp0) == 1.1569515572952029402736625857313236848570e-04": +Test "tgamma (-0x13.ffffffffffffp0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x14.000000000000000000000000001p0) == -1.3338743301940057859272772747599851284049e+14": +Test "tgamma (-0x14.000000000000000000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x14.000000000001p0) == -1.1569515572951781096476686854873801225397e-04": +Test "tgamma (-0x14.000000000001p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x14.00002p0) == -2.1549777908265594916405421768142757507179e-13": +Test "tgamma (-0x14.00002p0)": float: 1 ifloat: 1 ildouble: 4 ldouble: 4 -Test "tgamma (-0x1d.ffffep0) == 1.9765721589464867957912772592816027583176e-27": +Test "tgamma (-0x1d.ffffep0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1d.fffffffffffffffffffffffff8p0) == 9.5580541610429641982963434151488827190079e-03": +Test "tgamma (-0x1d.fffffffffffffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1d.ffffffffffffp0) == 1.0611571800204311628217068863959963842891e-18": +Test "tgamma (-0x1d.ffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1e.000000000000000000000000001p0) == -1.2234309326134994173819319571373948286903e+00": +Test "tgamma (-0x1e.000000000000000000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x1e.00000000000000000000000008p0) == -9.5580541610429641982963434151231128067179e-03": +Test "tgamma (-0x1e.00000000000000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1e.000000000000002p0) == -2.1732499046818166201837145753965837196590e-15": +Test "tgamma (-0x1e.000000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1e.000000000001p0) == -1.0611571800204053929094168642022073530425e-18": +Test "tgamma (-0x1e.000000000001p0)": double: 3 idouble: 3 -Test "tgamma (-0x1e.00002p0) == -1.9765463890341964384070157599286498212650e-27": +Test "tgamma (-0x1e.00002p0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1f3.ffffffffffffffffffffffffffp0) == 1.6623061587520224800948170558276526986560e-1103": +Test "tgamma (-0x1f3.ffffffffffffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1p-24) == -1.6777216577215723853867349114260580375249e+07": +Test "tgamma (-0x1p-24)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.0000000000000000000000000002p0) == -1.2980742146337069071326240823050235386078e+33": +Test "tgamma (-0x2.0000000000000000000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.0000000000002p0) == -1.1258999068426235386078324507668462444260e+15": +Test "tgamma (-0x2.0000000000002p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.000004p0) == -2.0971515386080557574407223895988378776747e+06": +Test "tgamma (-0x2.000004p0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.fffffcp0) == -6.9905087601970247876992248591045142913324e+05": +Test "tgamma (-0x2.fffffcp0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x2.ffffffffffffep0) == -3.7529996894754154268627807196691509198813e+14": +Test "tgamma (-0x2.ffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x27.fffffffffffep0) == 1.7249032006742266376460389310340465554361e-34": +Test "tgamma (-0x27.fffffffffffep0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x27.ffffffffffffffcp0) == 3.5326017549807232935581894777156474496719e-31": +Test "tgamma (-0x27.ffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x27.ffffffffffffffffffffffffffep0) == 1.9886779934224431790713007246380976767855e-16": +Test "tgamma (-0x27.ffffffffffffffffffffffffffep0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x27.fffffffffffffffffffffffffp0) == 1.5536546823612837336494536911280147806523e-18": +Test "tgamma (-0x27.fffffffffffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.0000000000000000000000001p0) == -1.5536546823612837336494536911189419578973e-18": +Test "tgamma (-0x28.0000000000000000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.000000000002p0) == -1.7249032006741359094184881234822934593822e-34": +Test "tgamma (-0x28.000000000002p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.00004p0) == -3.2128372159115252365699015758097981155793e-43": +Test "tgamma (-0x28.00004p0)": double: 2 idouble: 2 ildouble: 2 ldouble: 2 -Test "tgamma (-0x28.ffffffffffffffcp0) == -8.6161018414163982777002940498289948893044e-33": +Test "tgamma (-0x28.ffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.ffffffffffffffffffffffffffep0) == -4.8504341302986419001739042064343853066259e-18": +Test "tgamma (-0x28.ffffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.fffffffffffffffffffffffffp0) == -3.7894016642958139845108626612879138384405e-20": +Test "tgamma (-0x28.fffffffffffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.000000000000000000000000002p0) == 4.8504341302986419001739042064341625600656e-18": +Test "tgamma (-0x29.000000000000000000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.0000000000000000000000001p0) == 3.7894016642958139845108626612656391824122e-20": +Test "tgamma (-0x29.0000000000000000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x29.00004p0) == 7.8361876024016854597745353972619195760515e-45": +Test "tgamma (-0x29.00004p0)": double: 1 idouble: 1 -Test "tgamma (-0x29.ffffcp0) == 1.8658121573125798145204120066590953505132e-46": +Test "tgamma (-0x29.ffffcp0)": double: 1 idouble: 1 -Test "tgamma (-0x29.fffffffffffep0) == 1.0016859469652887505173040814397197718981e-37": +Test "tgamma (-0x29.fffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.ffffffffffffffcp0) == 2.0514528193848567329552463626090806737389e-34": +Test "tgamma (-0x29.ffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.ffffffffffffffffffffffffffep0) == 1.1548652691187242619461676681986633377063e-19": +Test "tgamma (-0x29.ffffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.fffffffffffffffffffffffffp0) == 9.0223849149900332964544349078285357440663e-22": +Test "tgamma (-0x29.fffffffffffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2a.000000000000000000000000002p0) == -1.1548652691187242619461676681986099638869e-19": +Test "tgamma (-0x2a.000000000000000000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2a.0000000000000000000000001p0) == -9.0223849149900332964544349077751619246306e-22": +Test "tgamma (-0x2a.0000000000000000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2a.000000000000004p0) == -2.0514528193848566795814269269517457847791e-34": +Test "tgamma (-0x2a.000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2a.000000000002p0) == -1.0016859469652353766978684241048308120274e-37": +Test "tgamma (-0x2a.000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2ed.fffffffffffffffffffffffffep0) == 3.9294757797334687313030998663853566763041e-1802": +Test "tgamma (-0x2ed.fffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2ee.00000000000004p0) == -6.9801511765871767194421856376592926002995e-1817": +Test "tgamma (-0x2ee.00000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3.00000000000000000000000001p0) == 3.3804016006086117373245418810024573137219e+30": +Test "tgamma (-0x3.00000000000000000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3.000004p0) == 6.9905045731381300146131914617735687322025e+05": +Test "tgamma (-0x3.000004p0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (-0x3.fffffcp0) == 1.7476272942159602684441970627092458855771e+05": +Test "tgamma (-0x3.fffffcp0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x3.ffffffffffffep0) == 9.3824992236885396088236184658402406857503e+13": +Test "tgamma (-0x3.ffffffffffffep0)": double: 2 idouble: 2 -Test "tgamma (-0x3.fffffffffffffffcp0) == 1.9215358410114116272942156951799168638773e+17": +Test "tgamma (-0x3.fffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3.fffffffffffffffffffffffffffep0) == 1.0817285121947557559438534019208539608824e+32": +Test "tgamma (-0x3.fffffffffffffffffffffffffffep0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x31.fffffffffffep0) == 4.6273774273632946947805289899230181990085e-51": +Test "tgamma (-0x31.fffffffffffep0)": double: 3 idouble: 3 ildouble: 2 ldouble: 2 -Test "tgamma (-0x31.ffffffffffffffcp0) == 9.4768689712397635680446279661359728835046e-48": +Test "tgamma (-0x31.ffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x31.ffffffffffffffffffffffffffep0) == 5.3350029459393017997786969431322287652396e-33": +Test "tgamma (-0x31.ffffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x31.fffffffffffffffffffffffffp0) == 4.1679710515150795310771069868348482819424e-35": +Test "tgamma (-0x31.fffffffffffffffffffffffffp0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x32.000000000000000000000000002p0) == -5.3350029459393017997786969431319708591664e-33": +Test "tgamma (-0x32.000000000000000000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x32.0000000000000000000000001p0) == -4.1679710515150795310771069868090576746248e-35": +Test "tgamma (-0x32.0000000000000000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x32.000000000000004p0) == -9.4768689712397633101385547903658075308777e-48": +Test "tgamma (-0x32.000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3e7.fffffffffffffcp0) == 4.4768809295877296071892611539415773519036e-2552": +Test "tgamma (-0x3e7.fffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3e7.fffffffffffffffffffffffffep0) == 2.5202599107841713834679953735597552855978e-2537": +Test "tgamma (-0x3e7.fffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3e8.00000000000000000000000002p0) == -2.5202599107841713834679953735563216504503e-2537": +Test "tgamma (-0x3e8.00000000000000000000000002p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x3e8.00000000000004p0) == -4.4768809295877261735541135972060089530309e-2552": +Test "tgamma (-0x3e8.00000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.0000000000004p0) == -4.6912496118442603911763815341745722862351e+13": +Test "tgamma (-0x4.0000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.000008p0) == -8.7381270578483499672965708923121931082305e+04": +Test "tgamma (-0x4.000008p0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.fffff8p0) == -1.7476280884325863043793087474680780379554e+04": +Test "tgamma (-0x4.fffff8p0)": double: 1 idouble: 1 -Test "tgamma (-0x4.ffffffffffffcp0) == -9.3824992236885475509805702650262155809819e+12": +Test "tgamma (-0x4.ffffffffffffcp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.fffffffffffffffffffffffffep0) == -8.4510040015215293433113547025080884313904e+28": +Test "tgamma (-0x4.fffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.fffffffffffffffffffffffffffcp0) == -1.0817285121947557559438534019208547550981e+31": +Test "tgamma (-0x4.fffffffffffffffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.0000000000000008p0) == 1.9215358410114116252449019429734996071487e+16": +Test "tgamma (-0x5.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.0000000000004p0) == 9.3824992236885191156860964016850034672946e+12": +Test "tgamma (-0x5.0000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.000008p0) == 1.7476252449031389167286893378510439443844e+04": +Test "tgamma (-0x5.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x5.fffff8p0) == 2.9127137122026653716311560165769071985443e+03": +Test "tgamma (-0x5.fffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.ffffffffffffcp0) == 1.5637498706147581566449098589862357835505e+12": +Test "tgamma (-0x5.ffffffffffffcp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.fffffffffffffff8p0) == 3.2025597350190193803788671320812043622696e+15": +Test "tgamma (-0x5.fffffffffffffff8p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x5.fffffffffffffffffffffffffep0) == 1.4085006669202548905518924504180378867132e+28": +Test "tgamma (-0x5.fffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.fffffffffffffffffffffffffffcp0) == 1.8028808536579262599064223365347581566449e+30": +Test "tgamma (-0x5.fffffffffffffffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5db.fffffffffffff8p0) == 1.8718211510339187689122114747834510481993e-4099": +Test "tgamma (-0x5db.fffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5db.fffffffffffffffffffffffffcp0) == 1.0537416297875703295453200836588944487917e-4084": +Test "tgamma (-0x5db.fffffffffffffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5dc.00000000000000000000000004p0) == -1.0537416297875703295453200836558547326520e-4084": +Test "tgamma (-0x5dc.00000000000000000000000004p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x6.0000000000000000000000000004p0) == -1.8028808536579262599064223365347529544662e+30": +Test "tgamma (-0x6.0000000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.00000000000000000000000002p0) == -1.4085006669202548905518924504175176688423e+28": +Test "tgamma (-0x6.00000000000000000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.0000000000004p0) == -1.5637498706147529544662012521330708016396e+12": +Test "tgamma (-0x6.0000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.000008p0) == -2.9127085100239567622341538102130981196910e+03": +Test "tgamma (-0x6.000008p0)": float: 2 ifloat: 2 ildouble: 2 ldouble: 2 -Test "tgamma (-0x6.fffff8p0) == -4.1610198723079349791939054365613377035519e+02": +Test "tgamma (-0x6.fffff8p0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.ffffffffffffcp0) == -2.2339283865925119357965832452642909859289e+11": +Test "tgamma (-0x6.ffffffffffffcp0)": double: 4 idouble: 4 ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.fffffffffffffff8p0) == -4.5750853357414562579675426149912896787735e+14": +Test "tgamma (-0x6.fffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.fffffffffffffffffffffffffffcp0) == -2.5755440766541803712948890521925119357966e+29": +Test "tgamma (-0x6.fffffffffffffffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x63.fffffffffffcp0) == 7.5400833348840965463348754984345825364294e-145": +Test "tgamma (-0x63.fffffffffffcp0)": double: 2 idouble: 2 -Test "tgamma (-0x63.ffffffffffffff8p0) == 1.5442090669841618542494279375256856430049e-141": +Test "tgamma (-0x63.ffffffffffffff8p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x63.ffffffffffffffffffffffffep0) == 6.7915032994648558610510614163560656864280e-129": +Test "tgamma (-0x63.ffffffffffffffffffffffffep0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x64.000000000000000000000000004p0) == -8.6931242233150155021453586128720401960966e-127": +Test "tgamma (-0x64.000000000000000000000000004p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x64.0000000000000000000000002p0) == -6.7915032994648558610510614162572689693253e-129": +Test "tgamma (-0x64.0000000000000000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x64.000000000004p0) == -7.5400833348831085791638490135462230991587e-145": +Test "tgamma (-0x64.000000000004p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x6d5.fffffffffffff8p0) == 4.2925786447266492555651378780094011518063e-4902": +Test "tgamma (-0x6d5.fffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x6d6.00000000000000000000000004p0) == -2.4165069481061837867659591369927521090377e-4887": +Test "tgamma (-0x6d6.00000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x6e3.00000000000000000000000004p0) == 1.5891611922804672355414813802961215945667e-4929": +Test "tgamma (-0x6e3.00000000000000000000000004p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x7.0000000000000008p0) == 4.5750853357414562499689653215166468353753e+14": +Test "tgamma (-0x7.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.0000000000004p0) == 2.2339283865925039372192897706214475877342e+11": +Test "tgamma (-0x7.0000000000004p0)": double: 3 idouble: 3 -Test "tgamma (-0x7.000008p0) == 4.1610118737306415004517215226199741948733e+02": +Test "tgamma (-0x7.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x7.fffff8p0) == 5.2012751504050764429534086402871289946986e+01": +Test "tgamma (-0x7.fffff8p0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "tgamma (-0x7.ffffffffffffcp0) == 2.7924104832406402297655703264222230055898e+10": +Test "tgamma (-0x7.ffffffffffffcp0)": double: 3 idouble: 3 -Test "tgamma (-0x7.fffffffffffffff8p0) == 5.7188566696768203227694481100089533685959e+13": +Test "tgamma (-0x7.fffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.fffffffffffffffffffffffffep0) == 2.5151797623575980188426650900322769448110e+26": +Test "tgamma (-0x7.fffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.fffffffffffffffffffffffffffcp0) == 3.2194300958177254641186113152406402297656e+28": +Test "tgamma (-0x7.fffffffffffffffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x8.0000000000000000000000000008p0) == -1.6097150479088627320593056576203121511868e+28": +Test "tgamma (-0x8.0000000000000000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x8.00000000000000000000000004p0) == -1.2575898811787990094213325450153421028080e+26": +Test "tgamma (-0x8.00000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x8.0000000000008p0) == -1.3962052416203121511868106259843527348026e+10": +Test "tgamma (-0x8.0000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x8.00001p0) == -2.6006296115134418896533598545925084576702e+01": +Test "tgamma (-0x8.00001p0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x9.ffffffffffff8p0) == 1.5513391573559147700413058496716749249803e+08": +Test "tgamma (-0x9.ffffffffffff8p0)": double: 1 idouble: 1 -Test "tgamma (-0x9.fffffffffffffffffffffffffff8p0) == 1.7885722754542919245103396195781369922635e+26": +Test "tgamma (-0x9.fffffffffffffffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x9.fffffp0) == 2.8896008370721717567612135720915723136310e-01": +Test "tgamma (-0x9.fffffp0)": float: 1 ifloat: 1 -Test "tgamma (-0x95.ffffffffffffffp0) == 1.2612069237291916400144732227892704713839e-246": +Test "tgamma (-0x95.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x96.000000000000000000000000008p0) == -7.0999637896798458052083945552077084073470e-232": +Test "tgamma (-0x96.000000000000000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x96.0000000000000000000000004p0) == -5.5468467106873795353190582461689495693675e-234": +Test "tgamma (-0x96.0000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x96.00000000000001p0) == -1.2612069237291914644980030550324645611752e-246": +Test "tgamma (-0x96.00000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x96.000000000008p0) == -6.1582369322705655439003240743176243138734e-250": +Test "tgamma (-0x96.000000000008p0)": double: 1 idouble: 1 -Test "tgamma (-0xa.0000000000008p0) == -1.5513391573559018084419393002828541166901e+08": +Test "tgamma (-0xa.0000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xa.00001p0) == -2.8895878754728051776830454190076999107021e-01": +Test "tgamma (-0xa.00001p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0xb4.ffffffffffffffffffffffffcp0) == -8.7154451775644399729745472278589884205029e-303": +Test "tgamma (-0xb4.ffffffffffffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb4.ffffffffffffffp0) == -1.9816628031468191243385005680879281767694e-315": +Test "tgamma (-0xb4.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb5.0000000000000000000000004p0) == 8.7154451775644399729745472275729078899858e-303": +Test "tgamma (-0xb5.0000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb5.00000000000001p0) == 1.9816628031468188382579700510291588022368e-315": +Test "tgamma (-0xb5.00000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xb5.000000000008p0) == 9.6760879059888966544677044221698800670218e-319": +Test "tgamma (-0xb5.000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb5.ffffffffffffffffffffffffff8p0) == 6.1295438611442215194546266216911239298981e-303": +Test "tgamma (-0xb5.ffffffffffffffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb6.00000000000001p0) == -1.0888257160147356253334423783317128355514e-317": +Test "tgamma (-0xb6.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb6.000000000008p0) == -5.3165318164774149139661976747137185876909e-321": +Test "tgamma (-0xb6.000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb6.fffffffffff8p0) == -2.9052086428846935908287469917922960610289e-323": +Test "tgamma (-0xb6.fffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb6.ffffffffffffffffffffffffff8p0) == -3.3494775197509407210134571703230189921356e-305": +Test "tgamma (-0xb6.ffffffffffffffffffffffffff8p0)": ildouble: 3 ldouble: 3 -Test "tgamma (-0xb7.000000000000000000000000008p0) == 3.3494775197509407210134571703221582364195e-305": +Test "tgamma (-0xb7.000000000000000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb7.00000000000001p0) == 5.9498673006269706297861824177538685763601e-320": +Test "tgamma (-0xb7.00000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xb7.000000000008p0) == 2.9052086428838328351126988236541632950925e-323": +Test "tgamma (-0xb7.000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb7.ffffffffffffffffffffffffcp0) == 1.4221626697312078468976975078030462044826e-309": +Test "tgamma (-0xb7.ffffffffffffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb7.ffffffffffffffffffffffffff8p0) == 1.8203682172559460440290528099581627396147e-307": +Test "tgamma (-0xb7.ffffffffffffffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb8.00000000000001p0) == -3.2336235329494405594225146768193434900135e-322": +Test "tgamma (-0xb8.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbb.ffffffffffffffffffffffffcp0) == 1.1756150745511026776007338998283058108448e-318": +Test "tgamma (-0xbb.ffffffffffffffffffffffffcp0)": ildouble: 3 ldouble: 3 -Test "tgamma (-0xbb.ffffffffffffffffffffffffff8p0) == 1.5047872954254114273289393917555491216542e-316": +Test "tgamma (-0xbb.ffffffffffffffffffffffffff8p0)": ildouble: 4 ldouble: 4 -Test "tgamma (-0xbc.000000000000000000000000008p0) == -1.5047872954254114273289393917551604237609e-316": +Test "tgamma (-0xbc.000000000000000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbc.0000000000000000000000004p0) == -1.1756150745511026776007338997894360215107e-318": +Test "tgamma (-0xbc.0000000000000000000000004p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xbc.00000000000001p0) == -2.6730392040715346232108532050343031951651e-331": +Test "tgamma (-0xbc.00000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xbc.ffffffffffffffp0) == -1.4143064571807063556111222197839950086445e-333": +Test "tgamma (-0xbc.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbd.000000000000000000000000008p0) == 7.9618375419333937953912137129902657538965e-319": +Test "tgamma (-0xbd.000000000000000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbd.00000000000001p0) == 1.4143064571807061497431633629389135273431e-333": +Test "tgamma (-0xbd.00000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xbd.ffffffffffffffp0) == 7.4437181956879281879706555863416819210399e-336": +Test "tgamma (-0xbd.ffffffffffffffp0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xbe.000000000000000000000000008p0) == -4.1904408115438914712585335331527709057227e-321": +Test "tgamma (-0xbe.000000000000000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbe.0000000000000000000000004p0) == -3.2737818840186652119207293227217957948294e-323": +Test "tgamma (-0xbe.0000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbe.ffffffffffffffffffffffffcp0) == -1.7140219288055838805867692789687487834686e-325": +Test "tgamma (-0xbe.ffffffffffffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbe.ffffffffffffffp0) == -3.8972346574282346536709453101948570578636e-338": +Test "tgamma (-0xbe.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbf.000000000000000000000000008p0) == 2.1939480688711473671510646770433352695669e-323": +Test "tgamma (-0xbf.000000000000000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbf.0000000000000000000000004p0) == 1.7140219288055838805867692789119066543632e-325": +Test "tgamma (-0xbf.0000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbf.00000000000001p0) == 3.8972346574282340852496542564155275274974e-338": +Test "tgamma (-0xbf.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xf9.ffffffffffffffp0) == 2.2289142548411573883553287678043297937797e-476": +Test "tgamma (-0xf9.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xfa.000000000000000000000000008p0) == -1.2547671759429278005937024349855091492502e-461": +Test "tgamma (-0xfa.000000000000000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-2.5) == -9.4530872048294188122568932444861076415869e-01": +Test "tgamma (-2.5)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-3.5) == 2.7008820585226910892162552127103164690248e-01": +Test "tgamma (-3.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-4.5) == -6.0019601300504246427027893615784810422774e-02": +Test "tgamma (-4.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-5.5) == 1.0912654781909862986732344293779056440504e-02": +Test "tgamma (-5.5)": double: 1 idouble: 1 -Test "tgamma (-6.5) == -1.6788699664476712287280529682737009908468e-03": +Test "tgamma (-6.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-7.5) == 2.2384932885968949716374039576982679877958e-04": +Test "tgamma (-7.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (-8.5) == -2.6335215159963470254557693619979623385833e-05": +Test "tgamma (-8.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-9.5) == 2.7721279115751021320587045915768024616666e-06": +Test "tgamma (-9.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0x1.fffffep0) == 9.9999994960018563231526611134590489120697e-01": +Test "tgamma (0x1.fffffep0)": float: 1 ifloat: 1 -Test "tgamma (0x1.fffffffffffffffep0) == 9.9999999999999999995416163053934024243282e-01": +Test "tgamma (0x1.fffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x1.ffffffffffffffffffffffffffffp0) == 9.9999999999999999999999999999999991857470e-01": +Test "tgamma (0x1.ffffffffffffffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x1.fffffffffffffp0) == 9.9999999999999990612301934456883679778984e-01": +Test "tgamma (0x1.fffffffffffffp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x1p-113) == 1.0384593717069655257060992658440191422784e+34": +Test "tgamma (0x1p-113)": ildouble: 1 ldouble: 1 -Test "tgamma (0x1p-24) == 1.6777215422784394050795179874582764575261e+07": +Test "tgamma (0x1p-24)": float: 1 ifloat: 1 -Test "tgamma (0x1p-53) == 9.0071992547409914227843350984672492007618e+15": +Test "tgamma (0x1p-53)": double: 1 idouble: 1 -Test "tgamma (0x2.30a43cp+4) == 3.4027979115654976101247558405326779640190e+38": +Test "tgamma (0x2.30a43cp+4)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 2 ldouble: 2 -Test "tgamma (0x2.fffffcp0) == 1.9999995599822108706107786027549565954046e+00": +Test "tgamma (0x2.fffffcp0)": float: 3 ifloat: 3 -Test "tgamma (0x2.ffffffffffffep0) == 1.9999999999999991804028675282128956223990e+00": +Test "tgamma (0x2.ffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x3.0000000000002p0) == 2.0000000000000008195971324717875960213536e+00": +Test "tgamma (0x3.0000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x3.fffffcp0) == 5.9999982031095793171233994481968816873643e+00": +Test "tgamma (0x3.fffffcp0)": float: 1 ifloat: 1 -Test "tgamma (0x3.ffffffffffffep0) == 5.9999999999999966530301828845138185025345e+00": +Test "tgamma (0x3.ffffffffffffep0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x3.fffffffffffffffcp0) == 5.9999999999999999983657373939865784753909e+00": +Test "tgamma (0x3.fffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x3.fffffffffffffffffffffffffffep0) == 5.9999999999999999999999999999999970969664e+00": +Test "tgamma (0x3.fffffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x4.0000000000000000000000000004p0) == 6.0000000000000000000000000000000058060671e+00": +Test "tgamma (0x4.0000000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x4.0000000000004p0) == 6.0000000000000066939396342309789716341613e+00": +Test "tgamma (0x4.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x4.000008p0) == 6.0000035937827461765660468073471093546129e+00": +Test "tgamma (0x4.000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x4.ffffffffffffcp0) == 2.3999999999999967895170944875373910918544e+01": +Test "tgamma (0x4.ffffffffffffcp0)": double: 1 idouble: 1 -Test "tgamma (0x4.fffffffffffffffffffffffffep0) == 2.3999999999999999999999999999996435647958e+01": +Test "tgamma (0x4.fffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x4.fffffffffffffffffffffffffffcp0) == 2.3999999999999999999999999999999972153500e+01": +Test "tgamma (0x4.fffffffffffffffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x5.0000000000000000000000000004p0) == 2.4000000000000000000000000000000027846500e+01": +Test "tgamma (0x5.0000000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x5.0000000000004p0) == 2.4000000000000032104829055124673225982803e+01": +Test "tgamma (0x5.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x5.000008p0) == 2.4000017236155647574166073485628713443799e+01": +Test "tgamma (0x5.000008p0)": float: 2 ifloat: 2 -Test "tgamma (0x5.fffff8p0) == 1.1999990237520611552119807476573441975106e+02": +Test "tgamma (0x5.fffff8p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0x5.ffffffffffffcp0) == 1.1999999999999981815957265157389249327533e+02": +Test "tgamma (0x5.ffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x5.fffffffffffffff8p0) == 1.1999999999999999991121072883377624326546e+02": +Test "tgamma (0x5.fffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x5.fffffffffffffffffffffffffep0) == 1.1999999999999999999999999999997981165708e+02": +Test "tgamma (0x5.fffffffffffffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x6.0000000000000000000000000004p0) == 1.2000000000000000000000000000000015772143e+02": +Test "tgamma (0x6.0000000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x6.0000000000000008p0) == 1.2000000000000000008878927116622375680433e+02": +Test "tgamma (0x6.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x6.0000000000004p0) == 1.2000000000000018184042734842640022086408e+02": +Test "tgamma (0x6.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x6.000008p0) == 1.2000009762487825358530770343720418162783e+02": +Test "tgamma (0x6.000008p0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (0x6.fffff8p0) == 7.1999935703082425988147448928288557689866e+02": +Test "tgamma (0x6.fffff8p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x6.ffffffffffffcp0) == 7.1999999999999880237602554542848858572672e+02": +Test "tgamma (0x6.ffffffffffffcp0)": double: 4 idouble: 4 -Test "tgamma (0x6.fffffffffffffff8p0) == 7.1999999999999999941522266872335324679893e+02": +Test "tgamma (0x6.fffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x7.0000000000000000000000000004p0) == 7.2000000000000000000000000000000103877321e+02": +Test "tgamma (0x7.0000000000000000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x7.0000000000000008p0) == 7.2000000000000000058477733127664675369681e+02": +Test "tgamma (0x7.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x7.0000000000004p0) == 7.2000000000000119762397445457359071259652e+02": +Test "tgamma (0x7.0000000000004p0)": double: 4 idouble: 4 -Test "tgamma (0x7.000008p0) == 7.2000064296977505705636258629805621178587e+02": +Test "tgamma (0x7.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0x7.fffff8p0) == 5.0399951558933225045148935487583089307135e+03": +Test "tgamma (0x7.fffff8p0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (0x7.ffffffffffffcp0) == 5.0399999999999909771437166339103165198442e+03": +Test "tgamma (0x7.ffffffffffffcp0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (0x7.fffffffffffffffffffffffffffcp0) == 5.0399999999999999999999999999999921739197e+03": +Test "tgamma (0x7.fffffffffffffffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x8.0000000000000000000000000008p0) == 5.0400000000000000000000000000000156521606e+03": +Test "tgamma (0x8.0000000000000000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x8.0000000000008p0) == 5.0400000000000180457125667322294144477136e+03": +Test "tgamma (0x8.0000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x8.00001p0) == 5.0400096882277802019946778420223050233915e+03": +Test "tgamma (0x8.00001p0)": double: 2 idouble: 2 -Test "tgamma (0xa.b9fd72b0fb238p+4) == 1.7976931348622298700886249281842651388250e+308": +Test "tgamma (0xa.b9fd72b0fb238p+4)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0xa.b9fd72b0fb23a9ddbf0d3804f8p+4) == 1.7976931348623158079372897140599422519044e+308": +Test "tgamma (0xa.b9fd72b0fb23a9ddbf0d3804f8p+4)": ildouble: 2 ldouble: 2 -Test "tgamma (10) == 362880": +Test "tgamma (10)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (18.5) == 1.4986120533153361177371791123515513270334e+15": +Test "tgamma (18.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (19.5) == 2.7724322986333718178137813578503699550119e+16": +Test "tgamma (19.5)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (2.5) == 1.3293403881791370204736256125058588870982e+00": +Test "tgamma (2.5)": float: 2 ifloat: 2 -Test "tgamma (23.5) == 5.3613035875444147334274983856108155717836e+21": +Test "tgamma (23.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (29.5) == 1.6348125198274266444378807806868221866931e+30": +Test "tgamma (29.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (3) == 2": +Test "tgamma (3)": float: 1 ifloat: 1 -Test "tgamma (3.5) == 3.3233509704478425511840640312646472177454e+00": +Test "tgamma (3.5)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (30.5) == 4.8226969334909086010917483030261254507447e+31": +Test "tgamma (30.5)": float: 1 ifloat: 1 -Test "tgamma (32.5) == 4.6334060788513904384988971821323500268029e+34": +Test "tgamma (32.5)": ildouble: 1 ldouble: 1 -Test "tgamma (33.5) == 1.5058569756267018925121415841930137587110e+36": +Test "tgamma (33.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (34.5) == 5.0446208683494513399156743070465960916817e+37": +Test "tgamma (34.5)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "tgamma (4) == 6": +Test "tgamma (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (4.5) == 1.1631728396567448929144224109426265262109e+01": +Test "tgamma (4.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (6) == 120": +Test "tgamma (6)": float: 1 ifloat: 1 -Test "tgamma (6.5) == 2.8788527781504436099631954670830006523720e+02": +Test "tgamma (6.5)": float: 1 ifloat: 1 -Test "tgamma (7) == 720": +Test "tgamma (7)": double: 1 idouble: 1 -Test "tgamma (7.5) == 1.8712543057977883464760770536039504240418e+03": +Test "tgamma (7.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (8) == 5040": +Test "tgamma (8)": double: 1 idouble: 1 -Test "tgamma (8.5) == 1.4034407293483412598570577902029628180313e+04": +Test "tgamma (8.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (9) == 40320": +Test "tgamma (9)": double: 1 idouble: 1 -Test "tgamma (9.5) == 1.1929246199460900708784991216725183953266e+05": +Test "tgamma (9.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # y0 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-60) == -2.6550076313426878432849115782108205929120e+1": +Test "y0 (0x1p-60)": ildouble: 1 ldouble: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p1023) == 8.2687542933709649327986678723012001545638e-155": +Test "y0 (0x1p1023)": ildouble: 1 ldouble: 1 -Test "y0 (0x1p16382) == 8.0839224448726336195866026476176740513439e-2467": +Test "y0 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "y0 (0x1p16383) == -3.8895531955766020648617743624167352352217e-2467": +Test "y0 (0x1p16383)": ildouble: 2 ldouble: 2 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -9241,50 +9241,50 @@ ildouble: 3 ldouble: 3 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 -Test "y1 (0.75) == -1.03759455076928541973767132140642198": +Test "y1 (0.75)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.001000001p+593) == 3.927269966354206207832593635798954916263e-90": +Test "y1 (0x1.001000001p+593)": ildouble: 1 ldouble: 1 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 idouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y1 (0x1p-30) == -6.8356527557643159612937462812258975438856e+08": +Test "y1 (0x1p-30)": ildouble: 1 ldouble: 1 -Test "y1 (0x1p1023) == 1.5665258060609012834424478437196679802783e-155": +Test "y1 (0x1p1023)": ildouble: 1 ldouble: 1 -Test "y1 (0x1p16383) == -9.5859502826270374691362975419147645151233e-2467": +Test "y1 (0x1p16383)": ildouble: 2 ldouble: 2 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 @@ -9293,105 +9293,105 @@ ildouble: 1 ldouble: 1 # yn -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 -Test "yn (1, 0.75) == -1.03759455076928541973767132140642198": +Test "yn (1, 0.75)": ildouble: 1 ldouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 5 ldouble: 5 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 ildouble: 2 ldouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 diff --git a/libc/sysdeps/sparc/sparc32/dl-machine.h b/libc/sysdeps/sparc/sparc32/dl-machine.h index 71e120f64..30f924678 100644 --- a/libc/sysdeps/sparc/sparc32/dl-machine.h +++ b/libc/sysdeps/sparc/sparc32/dl-machine.h @@ -411,8 +411,7 @@ elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc, strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/sysdeps/sparc/sparc64/dl-machine.h b/libc/sysdeps/sparc/sparc64/dl-machine.h index d6d20c729..3bce5d182 100644 --- a/libc/sysdeps/sparc/sparc64/dl-machine.h +++ b/libc/sysdeps/sparc/sparc64/dl-machine.h @@ -436,8 +436,7 @@ elf_machine_rela (struct link_map *map, const Elf64_Rela *reloc, strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]); _dl_error_printf ("\ %s: Symbol `%s' has different size in shared object, consider re-linking\n", - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + RTLD_PROGNAME, strtab + refsym->st_name); } memcpy (reloc_addr_arg, (void *) value, MIN (sym->st_size, refsym->st_size)); diff --git a/libc/sysdeps/unix/sysv/linux/bits/siginfo.h b/libc/sysdeps/unix/sysv/linux/bits/siginfo.h index a67bd5c0d..160378457 100644 --- a/libc/sysdeps/unix/sysv/linux/bits/siginfo.h +++ b/libc/sysdeps/unix/sysv/linux/bits/siginfo.h @@ -95,6 +95,7 @@ typedef struct struct { void *si_addr; /* Faulting insn/memory ref. */ + short int si_addr_lsb; /* Valid LSB of the reported address. */ } _sigfault; /* SIGPOLL. */ @@ -127,6 +128,7 @@ typedef struct # define si_int _sifields._rt.si_sigval.sival_int # define si_ptr _sifields._rt.si_sigval.sival_ptr # define si_addr _sifields._sigfault.si_addr +# define si_addr_lsb _sifields._sigfault.si_addr_lsb # define si_band _sifields._sigpoll.si_band # define si_fd _sifields._sigpoll.si_fd # define si_call_addr _sifields._sigsys._call_addr @@ -217,8 +219,12 @@ enum # define BUS_ADRALN BUS_ADRALN BUS_ADRERR, /* Non-existant physical address. */ # define BUS_ADRERR BUS_ADRERR - BUS_OBJERR /* Object specific hardware error. */ + BUS_OBJERR, /* Object specific hardware error. */ # define BUS_OBJERR BUS_OBJERR + BUS_MCEERR_AR, /* Hardware memory error: action required. */ +# define BUS_MCEERR_AR BUS_MCEERR_AR + BUS_MCEERR_AO /* Hardware memory error: action optional. */ +# define BUS_MCEERR_AO BUS_MCEERR_AO }; /* `si_code' values for SIGTRAP signal. */ diff --git a/libc/sysdeps/unix/sysv/linux/sparc/bits/siginfo.h b/libc/sysdeps/unix/sysv/linux/sparc/bits/siginfo.h index 85a54625e..88fa1dfd5 100644 --- a/libc/sysdeps/unix/sysv/linux/sparc/bits/siginfo.h +++ b/libc/sysdeps/unix/sysv/linux/sparc/bits/siginfo.h @@ -96,6 +96,7 @@ typedef struct { void *si_addr; /* Faulting insn/memory ref. */ int si_trapno; + short int si_addr_lsb; /* Valid LSB of the reported address. */ } _sigfault; /* SIGPOLL. */ @@ -129,6 +130,7 @@ typedef struct # define si_ptr _sifields._rt.si_sigval.sival_ptr # define si_addr _sifields._sigfault.si_addr # define si_trapno _sifields._sigfault.si_trapno +# define si_addr_lsb _sifields._sigfault.si_addr_lsb # define si_band _sifields._sigpoll.si_band # define si_fd _sifields._sigpoll.si_fd # define si_call_addr _sifields._sigsys._call_addr @@ -219,8 +221,12 @@ enum # define BUS_ADRALN BUS_ADRALN BUS_ADRERR, /* Non-existant physical address. */ # define BUS_ADRERR BUS_ADRERR - BUS_OBJERR /* Object specific hardware error. */ + BUS_OBJERR, /* Object specific hardware error. */ # define BUS_OBJERR BUS_OBJERR + BUS_MCEERR_AR, /* Hardware memory error: action required. */ +# define BUS_MCEERR_AR BUS_MCEERR_AR + BUS_MCEERR_AO /* Hardware memory error: action optional. */ +# define BUS_MCEERR_AO BUS_MCEERR_AO }; /* `si_code' values for SIGTRAP signal. */ diff --git a/libc/sysdeps/unix/sysv/linux/x86/bits/siginfo.h b/libc/sysdeps/unix/sysv/linux/x86/bits/siginfo.h index 48aef6db6..bfc6aa3b5 100644 --- a/libc/sysdeps/unix/sysv/linux/x86/bits/siginfo.h +++ b/libc/sysdeps/unix/sysv/linux/x86/bits/siginfo.h @@ -107,6 +107,7 @@ typedef struct struct { void *si_addr; /* Faulting insn/memory ref. */ + short int si_addr_lsb; /* Valid LSB of the reported address. */ } _sigfault; /* SIGPOLL. */ @@ -139,6 +140,7 @@ typedef struct # define si_int _sifields._rt.si_sigval.sival_int # define si_ptr _sifields._rt.si_sigval.sival_ptr # define si_addr _sifields._sigfault.si_addr +# define si_addr_lsb _sifields._sigfault.si_addr_lsb # define si_band _sifields._sigpoll.si_band # define si_fd _sifields._sigpoll.si_fd # define si_call_addr _sifields._sigsys._call_addr @@ -229,8 +231,12 @@ enum # define BUS_ADRALN BUS_ADRALN BUS_ADRERR, /* Non-existant physical address. */ # define BUS_ADRERR BUS_ADRERR - BUS_OBJERR /* Object specific hardware error. */ + BUS_OBJERR, /* Object specific hardware error. */ # define BUS_OBJERR BUS_OBJERR + BUS_MCEERR_AR, /* Hardware memory error: action required. */ +# define BUS_MCEERR_AR BUS_MCEERR_AR + BUS_MCEERR_AO /* Hardware memory error: action optional. */ +# define BUS_MCEERR_AO BUS_MCEERR_AO }; /* `si_code' values for SIGTRAP signal. */ diff --git a/libc/sysdeps/x86_64/dl-machine.h b/libc/sysdeps/x86_64/dl-machine.h index 4768c6954..116fed1b0 100644 --- a/libc/sysdeps/x86_64/dl-machine.h +++ b/libc/sysdeps/x86_64/dl-machine.h @@ -430,9 +430,7 @@ elf_machine_rela (struct link_map *map, const ElfW(Rela) *reloc, # endif strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]); - _dl_error_printf (fmt, - rtld_progname ?: "<program name unknown>", - strtab + refsym->st_name); + _dl_error_printf (fmt, RTLD_PROGNAME, strtab + refsym->st_name); } break; # ifndef RESOLVE_CONFLICT_FIND_MAP diff --git a/libc/sysdeps/x86_64/fpu/libm-test-ulps b/libc/sysdeps/x86_64/fpu/libm-test-ulps index 3827b9d76..db46ae127 100644 --- a/libc/sysdeps/x86_64/fpu/libm-test-ulps +++ b/libc/sysdeps/x86_64/fpu/libm-test-ulps @@ -1,5690 +1,5690 @@ # Begin of automatic generation # acos -Test "acos (0.75) == 0.722734247813415611178377352641333362": +Test "acos (0.75)": ildouble: 1 ldouble: 1 # acos_downward -Test "acos_downward (-0) == pi/2": +Test "acos_downward (-0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (-0.5) == M_PI_6l*4.0": +Test "acos_downward (-0.5)": double: 1 idouble: 1 -Test "acos_downward (-1) == pi": +Test "acos_downward (-1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (0) == pi/2": +Test "acos_downward (0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_downward (0.5) == M_PI_6l*2.0": +Test "acos_downward (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # acos_towardzero -Test "acos_towardzero (-0) == pi/2": +Test "acos_towardzero (-0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (-0.5) == M_PI_6l*4.0": +Test "acos_towardzero (-0.5)": double: 1 idouble: 1 -Test "acos_towardzero (-1) == pi": +Test "acos_towardzero (-1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (0) == pi/2": +Test "acos_towardzero (0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "acos_towardzero (0.5) == M_PI_6l*2.0": +Test "acos_towardzero (0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 # acos_upward -Test "acos_upward (-0.5) == M_PI_6l*4.0": +Test "acos_upward (-0.5)": ildouble: 1 ldouble: 1 -Test "acos_upward (0.5) == M_PI_6l*2.0": +Test "acos_upward (0.5)": ildouble: 1 ldouble: 1 # asin -Test "asin (-0.5) == -pi/6": +Test "asin (-0.5)": ildouble: 1 ldouble: 1 -Test "asin (-0x0.ffffffffffffffffp0) == -1.5707963264656243652399620683025688888978": +Test "asin (-0x0.ffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (-0x0.ffffffffffffp0) == -1.5707962425011995974432331617542781977068": +Test "asin (-0x0.ffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (-1.0) == -pi/2": +Test "asin (-1.0)": ildouble: 1 ldouble: 1 -Test "asin (0.5) == pi/6": +Test "asin (0.5)": ildouble: 1 ldouble: 1 -Test "asin (0.75) == 0.848062078981481008052944338998418080": +Test "asin (0.75)": ildouble: 1 ldouble: 1 -Test "asin (0x0.ffffffffffffffffp0) == 1.5707963264656243652399620683025688888978": +Test "asin (0x0.ffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (0x0.ffffffffffffp0) == 1.5707962425011995974432331617542781977068": +Test "asin (0x0.ffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "asin (1.0) == pi/2": +Test "asin (1.0)": ildouble: 1 ldouble: 1 # asin_downward -Test "asin_downward (-0.5) == -pi/6": +Test "asin_downward (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (0.5) == pi/6": +Test "asin_downward (0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_downward (1.0) == pi/2": +Test "asin_downward (1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # asin_tonearest -Test "asin_tonearest (-0.5) == -pi/6": +Test "asin_tonearest (-0.5)": ildouble: 1 ldouble: 1 -Test "asin_tonearest (-1.0) == -pi/2": +Test "asin_tonearest (-1.0)": ildouble: 1 ldouble: 1 -Test "asin_tonearest (0.5) == pi/6": +Test "asin_tonearest (0.5)": ildouble: 1 ldouble: 1 -Test "asin_tonearest (1.0) == pi/2": +Test "asin_tonearest (1.0)": ildouble: 1 ldouble: 1 # asin_towardzero -Test "asin_towardzero (-0.5) == -pi/6": +Test "asin_towardzero (-0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (-1.0) == -pi/2": +Test "asin_towardzero (-1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (0.5) == pi/6": +Test "asin_towardzero (0.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "asin_towardzero (1.0) == pi/2": +Test "asin_towardzero (1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # asin_upward -Test "asin_upward (-0.5) == -pi/6": +Test "asin_upward (-0.5)": ildouble: 1 ldouble: 1 -Test "asin_upward (-1.0) == -pi/2": +Test "asin_upward (-1.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "asin_upward (0.5) == pi/6": +Test "asin_upward (0.5)": ildouble: 1 ldouble: 1 # atan2 -Test "atan2 (-0.75, -1.0) == -2.49809154479650885165983415456218025": +Test "atan2 (-0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (-max_value, -min_value) == -pi/2": +Test "atan2 (-max_value, -min_value)": float: 1 ifloat: 1 -Test "atan2 (0.75, -1.0) == 2.49809154479650885165983415456218025": +Test "atan2 (0.75, -1.0)": float: 1 ifloat: 1 -Test "atan2 (1.390625, 0.9296875) == 0.981498387184244311516296577615519772": +Test "atan2 (1.390625, 0.9296875)": float: 1 ifloat: 1 # atanh -Test "atanh (0.75) == 0.972955074527656652552676371721589865": +Test "atanh (0.75)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cacos -Test "Imaginary part of: cacos (+0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (+0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (+0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 + 0.5 i) == pi/2 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.0 i) == pi/2 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 + 1.5 i) == pi/2 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0 - 0.5 i) == pi/2 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: cacos (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.0 i) == pi/2 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: cacos (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0 - 1.5 i) == pi/2 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 + 0x1p-23 i) == 1.570796326794896619231321691639751442099 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (-0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.0 - 0x1p-23 i) == 1.570796326794896619231321691639751442099 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (-0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.25 + 1.0 i) == 1.747098759571863549650000258275841544745 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (-0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Real part of: cacos (-0.25 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.25 - 1.0 i) == 1.747098759571863549650000258275841544745 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (-0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-1025 i) == 2.094395102393195492308428922186335256131 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1.fp-16385 i) == 2.094395102393195492308428922186335256131 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-105 i) == 2.094395102393195492308428922186335256131 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-112 i) == 2.094395102393195492308428922186335256131 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i) == 2.094395102393190022547898764614298351924 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 + 0x1p-52 i) == 2.094395102393195492308428922186316279087 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (-0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 + 1.0 i) == 1.920235389652109912858733517715121394831 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-1025 i) == 2.094395102393195492308428922186335256131 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i) == 2.094395102393195492308428922186335256131 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1.fp-16385 i) == 2.094395102393195492308428922186335256131 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-105 i) == 2.094395102393195492308428922186335256131 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-112 i) == 2.094395102393195492308428922186335256131 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i) == 2.094395102393190022547898764614298351924 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0.5 - 0x1p-52 i) == 2.094395102393195492308428922186316279087 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (-0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0.5 - 1.0 i) == 1.920235389652109912858733517715121394831 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (-0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 3.141592634635223399311902261000251614142 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 3.141592634635223399311902261000251614142 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 3.141592653260520984471283759942320330996 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == 3.141592653170952461345846619605307690007 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 3.141592653260520984471283759942320330996 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == 3.141592653170952461345846619605307690007 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i) == 3.141153467203602189751698864505105063797 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i) == 3.141153467203602189751698864505105063797 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (-0x1.0000000000000002p0 + 0x1p-63 i) == 3.141592653377875508152537040020250564229 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0x1.0000000000000002p0 - 0x1p-63 i) == 3.141592653377875508152537040020250564229 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0.0 i) == 3.141592653589793238462643383279502884197 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1p-52 i) == 3.141592643999491532482601997450598791535 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0.0 i) == 3.141592653589793238462643383279502884197 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1p-52 i) == 3.141592643999491532482601997450598791535 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.000002p0 + 0x1p-23 i) == 3.141370441751352383825802745874586120521 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.000002p0 - 0x1p-23 i) == 3.141370441751352383825802745874586120521 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i) == 1.572134236154454360143880041170803681211 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i) == 1.572134236154454360143880041170803681211 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691640832196834 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-100 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691640832196834 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691640832196834 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-100 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691640832196834 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442101 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442101 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x0.ffffffp0 i) == 1.570796326794896619231321691639751442101 - 8.813735448726938863015878255140556727969e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 - 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1.fp-129 i) == 1.570796326794896619231321691639751442101 - 2.846900380897727558361783801085126250967e-39 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 0x1p-23 i) == 1.570796326794896619231321691639751442101 - 1.192092895507809676556842485683592032154e-7 i": +Test "Real part of: cacos (-0x1.fp-129 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 0x1p-23 i) == 1.570796326794896619231321691639751442101 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442101 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-129 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442101 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1.fp-129 + 1.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442100 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442101 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442101 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x0.ffffffp0 i) == 1.570796326794896619231321691639751442101 + 8.813735448726938863015878255140556727969e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 + 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442101 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1.fp-129 i) == 1.570796326794896619231321691639751442101 + 2.846900380897727558361783801085126250967e-39 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 0x1p-23 i) == 1.570796326794896619231321691639751442101 + 1.192092895507809676556842485683592032154e-7 i": +Test "Real part of: cacos (-0x1.fp-129 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 0x1p-23 i) == 1.570796326794896619231321691639751442101 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442101 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: cacos (-0x1.fp-129 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442101 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Real part of: cacos (-0x1.fp-129 - 1.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442100 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-30 + 1.0 i) == 1.570796328070826603447840231892468927106 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: cacos (-0x1.fp-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i) == 1.570796328070826603447840231892468927106 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1.fp-30 - 1.0 i) == 1.570796328070826603447840231892468927106 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: cacos (-0x1.fp-30 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i) == 1.570796328070826603447840231892468927106 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-105 + 0.0 i) == 1.570796326794896619231321691639776094002 - 0.0 i": +Test "Real part of: cacos (-0x1p-105 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 + 0.5 i) == 1.570796326794896619231321691639773491431 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i) == 1.570796326794896619231321691639773491431 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 + 0x1p-105 i) == 1.570796326794896619231321691639776094002 - 2.465190328815661891911651766508706967729e-32 i": +Test "Real part of: cacos (-0x1p-105 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 - 0.0 i) == 1.570796326794896619231321691639776094002 + 0.0 i": +Test "Real part of: cacos (-0x1p-105 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 - 0.5 i) == 1.570796326794896619231321691639773491431 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i) == 1.570796326794896619231321691639773491431 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-105 - 0x1p-105 i) == 1.570796326794896619231321691639776094002 + 2.465190328815661891911651766508706967729e-32 i": +Test "Real part of: cacos (-0x1p-105 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0.0 i) == 1.570796326794896619231321691639751634692 - 0.0 i": +Test "Real part of: cacos (-0x1p-112 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751614359 - 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751614359 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 + 0x1p-112 i) == 1.570796326794896619231321691639751634692 - 1.925929944387235853055977942584927318538e-34 i": +Test "Real part of: cacos (-0x1p-112 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0.0 i) == 1.570796326794896619231321691639751634692 + 0.0 i": +Test "Real part of: cacos (-0x1p-112 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751614359 + 4.812118250596034474977589134243684231352e-1 i": +Test "Real part of: cacos (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751614359 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-112 - 0x1p-112 i) == 1.570796326794896619231321691639751634692 + 1.925929944387235853055977942584927318538e-34 i": +Test "Real part of: cacos (-0x1p-112 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 + 0.0 i) == 1.570796446004186170012854035955502877351 - 0.0 i": +Test "Real part of: cacos (-0x1p-23 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 + 0.5 i) == 1.570796433418926613232299739606181733819 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: cacos (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i) == 1.570796433418926613232299739606181733819 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-23 + 0x1.000002p0 i) == 1.570796411088588616723617301287646121905 - 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-23 + 0x1.fp-129 i) == 1.570796446004186170012854035955502877351 - 2.846900380897747786805634596726756660388e-39 i": +Test "Real part of: cacos (-0x1p-23 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 + 0x1p-23 i) == 1.570796446004186170012007003008248567984 - 1.192092895507818146886315028596704749235e-7 i": +Test "Real part of: cacos (-0x1p-23 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 - 0.0 i) == 1.570796446004186170012854035955502877351 + 0.0 i": +Test "Real part of: cacos (-0x1p-23 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 - 0.5 i) == 1.570796433418926613232299739606181733819 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: cacos (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i) == 1.570796433418926613232299739606181733819 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i) == 1.570796411088596153167306681647360823228 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-23 - 0x1.000002p0 i) == 1.570796411088588616723617301287646121905 + 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: cacos (-0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-23 - 0x1.fp-129 i) == 1.570796446004186170012854035955502877351 + 2.846900380897747786805634596726756660388e-39 i": +Test "Real part of: cacos (-0x1p-23 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-23 - 0x1p-23 i) == 1.570796446004186170012007003008248567984 + 1.192092895507818146886315028596704749235e-7 i": +Test "Real part of: cacos (-0x1p-23 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 + 0.0 i) == 1.570796326794896841275926616671059526825 - 0.0 i": +Test "Real part of: cacos (-0x1p-52 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 + 0.5 i) == 1.570796326794896817834053951421591208280 - 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: cacos (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i) == 1.570796326794896817834053951421591208280 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-52 + 0x1p-52 i) == 1.570796326794896841275926616671059526825 - 2.220446049250313080847263336181677117148e-16 i": +Test "Real part of: cacos (-0x1p-52 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 - 0.0 i) == 1.570796326794896841275926616671059526825 + 0.0 i": +Test "Real part of: cacos (-0x1p-52 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-52 - 0.5 i) == 1.570796326794896817834053951421591208280 + 4.812118250596034474977589134243772428682e-1 i": +Test "Real part of: cacos (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i) == 1.570796326794896817834053951421591208280 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-52 - 0x1p-52 i) == 1.570796326794896841275926616671059526825 + 2.220446049250313080847263336181677117148e-16 i": +Test "Real part of: cacos (-0x1p-52 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 + 0.0 i) == 1.570796326794896619339741908888301885499 - 0.0 i": +Test "Real part of: cacos (-0x1p-63 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 + 0.5 i) == 1.570796326794896619328295682000973043547 - 4.812118250596034474977589134243684231373e-1 i": +Test "Real part of: cacos (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i) == 1.570796326794896619328295682000973043547 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619307986362473920146173 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-63 + 0x1p-63 i) == 1.570796326794896619339741908888301885499 - 1.084202172485504434007452800869941711430e-19 i": +Test "Real part of: cacos (-0x1p-63 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 - 0.0 i) == 1.570796326794896619339741908888301885499 + 0.0 i": +Test "Real part of: cacos (-0x1p-63 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (-0x1p-63 - 0.5 i) == 1.570796326794896619328295682000973043547 + 4.812118250596034474977589134243684231373e-1 i": +Test "Real part of: cacos (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i) == 1.570796326794896619328295682000973043547 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619307986362473920146173 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-0x1p-63 - 0x1p-63 i) == 1.570796326794896619339741908888301885499 + 1.084202172485504434007452800869941711430e-19 i": +Test "Real part of: cacos (-0x1p-63 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 + 0.5 i) == 2.466703808003786858297978415967328452322 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 + 0x1.fp-30 i) == 3.141550174918818561961484385371624132331 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 + 0x1p50 i) == 1.570796326794897507409741391764983781004 - 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-1.0 + 0x1p50 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.0 - 0.5 i) == 2.466703808003786858297978415967328452322 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i) == 3.098101355958774410750062883737683164607 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.0 - 0x1.fp-30 i) == 3.141550174918818561961484385371624132331 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-1.0 - 0x1p50 i) == 1.570796326794897507409741391764983781004 + 3.535050620855721078027883819436759661753e1 i": +Test "Real part of: cacos (-1.0 - 0x1p50 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (-1.5 + +0 i) == pi - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + 0x1.fp-129 i) == 3.141592653589793238462643383279502884195 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 + 0x1.fp-16385 i) == 3.141592653589793238462643383279502884197 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0 i) == pi + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (-1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0x1.fp-1025 i) == 3.141592653589793238462643383279502884197 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0x1.fp-129 i) == 3.141592653589793238462643383279502884195 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (-1.5 - 0x1.fp-16385 i) == 3.141592653589793238462643383279502884197 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (-2 - 3 i) == 2.1414491111159960199416055713254211 + 1.9833870299165354323470769028940395 i": +Test "Real part of: cacos (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 + 0x1p-23 i) == 1.570796326794896619231321691639751442099 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442099 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.0 - 0x1p-23 i) == 1.570796326794896619231321691639751442099 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.25 + 1.0 i) == 1.394493894017929688812643125003661339452 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.25 - 1.0 i) == 1.394493894017929688812643125003661339452 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: cacos (0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + +0 i) == 1.047197551196597746154214461093167628066 - 0 i": +Test "Real part of: cacos (0.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 - 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1.fp-16385 i) == 1.047197551196597746154214461093167628066 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-105 i) == 1.047197551196597746154214461093167628066 - 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-105 i) == 1.047197551196597746154214461093167628066 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-112 i) == 1.047197551196597746154214461093167628066 - 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-112 i) == 1.047197551196597746154214461093167628066 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-23 i) == 1.047197551196603215914744618665204532273 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-52 i) == 1.047197551196597746154214461093186605110 - 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 + 0x1p-52 i) == 1.047197551196597746154214461093186605110 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 + 0x1p-63 i) == 1.047197551196597746154214461093167628070 - 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 + 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 + 1.0 i) == 1.221357263937683325603909865564381489366 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.5 + 1.0 i) == 1.221357263937683325603909865564381489366 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0 i) == 1.047197551196597746154214461093167628066 + +0 i": +Test "Real part of: cacos (0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 + 6.222508863508420569166420770843207333493e-309 i": +Test "Real part of: cacos (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-1025 i) == 1.047197551196597746154214461093167628066 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Real part of: cacos (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i) == 1.047197551196597746154214461093167628066 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1.fp-16385 i) == 1.047197551196597746154214461093167628066 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: cacos (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-105 i) == 1.047197551196597746154214461093167628066 + 2.846556599890768890940941645338546615370e-32 i": +Test "Real part of: cacos (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-105 i) == 1.047197551196597746154214461093167628066 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-112 i) == 1.047197551196597746154214461093167628066 + 2.223872343664663196047610660420739543258e-34 i": +Test "Real part of: cacos (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-112 i) == 1.047197551196597746154214461093167628066 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-23 i) == 1.047197551196603215914744618665204532273 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-52 i) == 1.047197551196597746154214461093186605110 + 2.563950248511418570403591756798643804971e-16 i": +Test "Real part of: cacos (0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0.5 - 0x1p-52 i) == 1.047197551196597746154214461093186605110 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: cacos (0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0.5 - 0x1p-63 i) == 1.047197551196597746154214461093167628070 + 1.251928832280966098829878787499365228659e-19 i": +Test "Real part of: cacos (0.5 - 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacos (0.5 - 1.0 i) == 1.221357263937683325603909865564381489366 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: cacos (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0.5 - 1.0 i) == 1.221357263937683325603909865564381489366 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: cacos (0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0.75 + 1.25 i) == 1.11752014915610270578240049553777969 - 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: cacos (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 - 1.171456840272878582596796205397918831268e-8 i": +Test "Real part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 + 1.171456840272878582596796205397918831268e-8 i": +Test "Real part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.895456983915074112227925127005564372844e-8 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: cacos (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 3.292722539913596233371825532007990724506e-10 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 - 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 3.292722539913596233371825532007990724506e-10 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 + 2.588578361325995866221775673638805081337e-10 i": +Test "Real part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 4.188407771167967636741951941902992986043e-10 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: cacos (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i) == 3.452669847162035876032494826387364972849e-4 - 0.0 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i) == 3.452669847162035876032494826387364972849e-4 - 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i) == 3.452669847162035876032494826387364972849e-4 + 0.0 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i) == 3.452669847162035876032494826387364972849e-4 + 8.245504387859737323891843603996428534945e-36 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Real part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i) == 4.391863861910487109445187743978204002614e-4 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: cacos (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 - 5.116146586219826555037807251857670783420e-10 i": +Test "Real part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 + 5.116146586219826555037807251857670783420e-10 i": +Test "Real part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i) == 2.119177303101063432592523199680782317447e-10 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: cacos (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0.0 i) == 0.0 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1.fp-1025 i) == 2.557178503953494342609835913586108008322e-301 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 - 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0.0 i) == 0.0 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1.fp-1025 i) == 2.557178503953494342609835913586108008322e-301 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 + 2.315303644582684770975188768022139415020e-8 i": +Test "Real part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1p-52 i) == 9.590301705980041385828904092662391018164e-9 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: cacos (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 - 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (0x1.000002p0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x1.000002p0 + 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 + 5.364668491573609633134147164031476452679e-4 i": +Test "Real part of: cacos (0x1.000002p0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacos (0x1.000002p0 - 0x1p-23 i) == 2.222118384408546368406374049167636760903e-4 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: cacos (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i) == 1.569458417435338878318763342108699202986 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i) == 1.569458417435338878318763342108699202986 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: cacos (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i) == 1.570796326794896619231321691638670687364 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i) == 1.570796326794896619231321691638670687364 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i) == 1.570796326794896619231321691639751442099 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i) == 1.570796326794896619231321691639751442099 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i) == 1.570796326794896619231321691639751442096 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0x1.000002p0 i) == 1.570796326794896619231321691639751442097 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 0x1p-23 i) == 1.570796326794896619231321691639751442096 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i) == 1.570796326794896619231321691639751442097 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i) == 1.570796326794896619231321691639751442097 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i) == 1.570796326794896619231321691639751442096 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0x1.000002p0 i) == 1.570796326794896619231321691639751442097 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 0x1p-23 i) == 1.570796326794896619231321691639751442096 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i) == 1.570796326794896619231321691639751442097 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i) == 1.570796326794896619231321691639751442097 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: cacos (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619231321691639751442099 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: cacos (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i) == 1.570796325518966635014803151387033957091 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i) == 1.570796325518966635014803151387033957091 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: cacos (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 - 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: cacos (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 - 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: cacos (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacos (0x1.fp16383 + 0x1.fp16383 i) == 7.853981633974483096156608458198757210493e-1 - 1.135753137836666928715489992987020363057e4 i": +Test "Imaginary part of: cacos (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-105 + 0.5 i) == 1.570796326794896619231321691639729392766 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-105 - 0.5 i) == 1.570796326794896619231321691639729392766 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-112 + 0.5 i) == 1.570796326794896619231321691639751269838 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-112 - 0.5 i) == 1.570796326794896619231321691639751269838 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: cacos (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0.5 i) == 1.570796220170866625230343643673321150378 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 + 0x1.000002p0 i) == 1.570796242501204621739026081991856762292 - 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: cacos (0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0.5 i) == 1.570796220170866625230343643673321150378 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i) == 1.570796242501197085295336701632142060969 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-23 - 0x1.000002p0 i) == 1.570796242501204621739026081991856762292 + 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: cacos (0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 + 0.5 i) == 1.570796326794896420628589431857911675917 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-52 - 0.5 i) == 1.570796326794896420628589431857911675917 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: cacos (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0.5 i) == 1.570796326794896619134347701278529840650 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 1.570796326794896619154657020805582738025 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0.5 i) == 1.570796326794896619134347701278529840650 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 1.570796326794896619154657020805582738025 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: cacos (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0.25 i) == 4.890443302710802929202843732146540079124e-1 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: cacos (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 + 0.5 i) == 6.748888455860063801646649673121744318756e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 + 0x1.fp-10 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 + 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0.25 i) == 4.890443302710802929202843732146540079124e-1 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: cacos (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacos (1.0 - 0.5 i) == 6.748888455860063801646649673121744318756e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: cacos (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Real part of: cacos (1.0 - 0x1.fp-10 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i) == 4.349129763101882771258049954181971959031e-2 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: cacos (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.0 - 0x1.fp-30 i) == 4.247867097467650115899790787875186617316e-5 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: cacos (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + +0 i) == +0 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + 0x1.fp-1025 i) == 4.819934639999230680322935210539402497827e-309 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + 0x1.fp-129 i) == 2.546345110742945032959687790021055102355e-39 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 + 0x1.fp-16385 i) == 7.282957076134209141226696333885150260319e-4933 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0 i) == +0 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: cacos (1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0x1.fp-1025 i) == 4.819934639999230680322935210539402497827e-309 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0x1.fp-129 i) == 2.546345110742945032959687790021055102355e-39 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacos (1.5 - 0x1.fp-16385 i) == 7.282957076134209141226696333885150260319e-4933 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: cacos (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # cacosh -Test "Real part of: cacosh (+0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (+0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (+0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 + 0.5 i) == 0.4812118250596034474977589134243684231352 + pi/2 i": +Test "Real part of: cacosh (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.0 i) == 0.8813735870195430252326093249797923090282 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 + 1.5 i) == 1.194763217287109304111930828519090523536 + pi/2 i": +Test "Real part of: cacosh (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0 - 0.5 i) == 0.4812118250596034474977589134243684231352 - pi/2 i": +Test "Real part of: cacosh (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.0 i) == 0.8813735870195430252326093249797923090282 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0 - 1.5 i) == 1.194763217287109304111930828519090523536 - pi/2 i": +Test "Real part of: cacosh (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.0 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Real part of: cacosh (-0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Real part of: cacosh (-0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.747098759571863549650000258275841544745 i": +Test "Imaginary part of: cacosh (-0.25 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 2.094395102393195492308428922186316279087 i": +Test "Real part of: cacosh (-0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.920235389652109912858733517715121394831 i": +Test "Imaginary part of: cacosh (-0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 2.094395102393195492308428922186335256131 i": +Test "Real part of: cacosh (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 2.094395102393190022547898764614298351924 i": +Test "Real part of: cacosh (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 2.094395102393195492308428922186316279087 i": +Test "Real part of: cacosh (-0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Real part of: cacosh (-0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.920235389652109912858733517715121394831 i": +Test "Imaginary part of: cacosh (-0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 3.141592634635223399311902261000251614142 i": +Test "Real part of: cacosh (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 + 3.141592653260520984471283759942320330996 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 3.141592653170952461345846619605307690007 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 - 3.141592653260520984471283759942320330996 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 3.141592653170952461345846619605307690007 i": +Test "Real part of: cacosh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 3.141153467203602189751698864505105063797 i": +Test "Real part of: cacosh (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (-0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 3.141592653377875508152537040020250564229 i": +Test "Real part of: cacosh (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacosh (-0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 3.141592653377875508152537040020250564229 i": +Test "Real part of: cacosh (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cacosh (-0x1.0000000000001p0 + 0.0 i) == 2.107342425544701550354780375182800088393e-8 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 3.141592643999491532482601997450598791535 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 - 0.0 i) == 2.107342425544701550354780375182800088393e-8 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 3.141592643999491532482601997450598791535 i": +Test "Real part of: cacosh (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 3.141370441751352383825802745874586120521 i": +Test "Real part of: cacosh (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 3.141370441751352383825802745874586120521 i": +Test "Real part of: cacosh (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.572134236154454360143880041170803681211 i": +Test "Real part of: cacosh (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691640832196834 i": +Test "Imaginary part of: cacosh (-0x1.fp-100 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691640832196834 i": +Test "Real part of: cacosh (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691640832196834 i": +Test "Imaginary part of: cacosh (-0x1.fp-100 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x0.ffffffp0 i) == 8.813735448726938863015878255140556727969e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.fp-129 i) == 2.846900380897727558361783801085126250967e-39 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442100 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 + 1.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x0.ffffffp0 i) == 8.813735448726938863015878255140556727969e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x0.ffffffp0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.fp-129 i) == 2.846900380897727558361783801085126250967e-39 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442101 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442101 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442100 i": +Test "Real part of: cacosh (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442100 i": +Test "Imaginary part of: cacosh (-0x1.fp-129 - 1.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796328070826603447840231892468927106 i": +Test "Imaginary part of: cacosh (-0x1.fp-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796328070826603447840231892468927106 i": +Test "Real part of: cacosh (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796328070826603447840231892468927106 i": +Test "Imaginary part of: cacosh (-0x1.fp-30 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0.0 i) == 0.0 + 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639773491431 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 + 0x1p-105 i) == 2.465190328815661891911651766508706967729e-32 + 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0.0 i) == 0.0 - 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639773491431 i": +Test "Real part of: cacosh (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639773491431 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-105 - 0x1p-105 i) == 2.465190328815661891911651766508706967729e-32 - 1.570796326794896619231321691639776094002 i": +Test "Imaginary part of: cacosh (-0x1p-105 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0.0 i) == 0.0 + 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751614359 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 + 0x1p-112 i) == 1.925929944387235853055977942584927318538e-34 + 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0.0 i) == 0.0 - 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751614359 i": +Test "Real part of: cacosh (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751614359 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-112 - 0x1p-112 i) == 1.925929944387235853055977942584927318538e-34 - 1.570796326794896619231321691639751634692 i": +Test "Imaginary part of: cacosh (-0x1p-112 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0.0 i) == 0.0 + 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796433418926613232299739606181733819 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-23 + 0x1.000002p0 i) == 8.813736713132400470205730751186547909968e-1 + 1.570796411088588616723617301287646121905 i": +Test "Real part of: cacosh (-0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0x1.fp-129 i) == 2.846900380897747786805634596726756660388e-39 + 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 + 0x1p-23 i) == 1.192092895507818146886315028596704749235e-7 + 1.570796446004186170012007003008248567984 i": +Test "Imaginary part of: cacosh (-0x1p-23 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0.0 i) == 0.0 - 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796433418926613232299739606181733819 i": +Test "Real part of: cacosh (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796433418926613232299739606181733819 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796411088596153167306681647360823228 i": +Test "Real part of: cacosh (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-0x1p-23 - 0x1.000002p0 i) == 8.813736713132400470205730751186547909968e-1 - 1.570796411088588616723617301287646121905 i": +Test "Real part of: cacosh (-0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0x1.fp-129 i) == 2.846900380897747786805634596726756660388e-39 - 1.570796446004186170012854035955502877351 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-23 - 0x1p-23 i) == 1.192092895507818146886315028596704749235e-7 - 1.570796446004186170012007003008248567984 i": +Test "Imaginary part of: cacosh (-0x1p-23 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0.0 i) == 0.0 + 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896817834053951421591208280 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 + 0x1p-52 i) == 2.220446049250313080847263336181677117148e-16 + 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 + 0x1p-52 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0.0 i) == 0.0 - 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896817834053951421591208280 i": +Test "Real part of: cacosh (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896817834053951421591208280 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-52 - 0x1p-52 i) == 2.220446049250313080847263336181677117148e-16 - 1.570796326794896841275926616671059526825 i": +Test "Imaginary part of: cacosh (-0x1p-52 - 0x1p-52 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0.0 i) == 0.0 + 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619328295682000973043547 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 + 1.570796326794896619307986362473920146173 i": +Test "Real part of: cacosh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-63 + 0x1p-63 i) == 1.084202172485504434007452800869941711430e-19 + 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 + 0x1p-63 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0.0 i) == 0.0 - 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619328295682000973043547 i": +Test "Real part of: cacosh (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619328295682000973043547 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 - 1.570796326794896619307986362473920146173 i": +Test "Real part of: cacosh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-0x1p-63 - 0x1p-63 i) == 1.084202172485504434007452800869941711430e-19 - 1.570796326794896619339741908888301885499 i": +Test "Imaginary part of: cacosh (-0x1p-63 - 0x1p-63 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 3.098101355958774410750062883737683164607 i": +Test "Real part of: cacosh (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 + 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 + 3.141550174918818561961484385371624132331 i": +Test "Real part of: cacosh (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 + 0x1p50 i) == 3.535050620855721078027883819436759661753e1 + 1.570796326794897507409741391764983781004 i": +Test "Imaginary part of: cacosh (-1.0 + 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 2.466703808003786858297978415967328452322 i": +Test "Real part of: cacosh (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 3.098101355958774410750062883737683164607 i": +Test "Real part of: cacosh (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.0 - 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 - 3.141550174918818561961484385371624132331 i": +Test "Real part of: cacosh (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-1.0 - 0x1p50 i) == 3.535050620855721078027883819436759661753e1 - 1.570796326794897507409741391764983781004 i": +Test "Imaginary part of: cacosh (-1.0 - 0x1p50 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (-1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + pi i": +Test "Real part of: cacosh (-1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 + 3.141592653589793238462643383279502884195 i": +Test "Real part of: cacosh (-1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 + 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - pi i": +Test "Real part of: cacosh (-1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 - 3.141592653589793238462643383279502884195 i": +Test "Real part of: cacosh (-1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (-1.5 - 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 - 3.141592653589793238462643383279502884197 i": +Test "Real part of: cacosh (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (-2 - 3 i) == 1.9833870299165354323470769028940395 - 2.1414491111159960199416055713254211 i": +Test "Imaginary part of: cacosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.0 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.25 + 1.0 i) == 8.924633639033482359562124741744951972772e-1 + 1.394493894017929688812643125003661339452 i": +Test "Real part of: cacosh (0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.25 - 1.0 i) == 8.924633639033482359562124741744951972772e-1 - 1.394493894017929688812643125003661339452 i": +Test "Real part of: cacosh (0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + +0 i) == +0 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 + 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 + 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 1.047197551196597746154214461093186605110 i": +Test "Real part of: cacosh (0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 + 1.047197551196597746154214461093186605110 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 + 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 + 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 + 1.0 i) == 9.261330313501824245501244453057873152694e-1 + 1.221357263937683325603909865564381489366 i": +Test "Imaginary part of: cacosh (0.5 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0.5 - 0 i) == +0 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i) == 6.222508863508420569166420770843207333493e-309 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i) == 3.287317402534702257036015056278368274737e-39 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1.fp-16385 i) == 9.402257155670418112159334875199821342890e-4933 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i) == 2.846556599890768890940941645338546615370e-32 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 1.047197551196597746154214461093167628066 i": +Test "Real part of: cacosh (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i) == 2.223872343664663196047610660420739543258e-34 - 1.047197551196597746154214461093167628066 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-23 i) == 1.376510308240943236356088341381173571841e-7 - 1.047197551196603215914744618665204532273 i": +Test "Real part of: cacosh (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 1.047197551196597746154214461093186605110 i": +Test "Real part of: cacosh (0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i) == 2.563950248511418570403591756798643804971e-16 - 1.047197551196597746154214461093186605110 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-52 i)": double: 1 idouble: 1 -Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i) == 1.251928832280966098829878787499365228659e-19 - 1.047197551196597746154214461093167628070 i": +Test "Imaginary part of: cacosh (0.5 - 0x1p-63 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.221357263937683325603909865564381489366 i": +Test "Real part of: cacosh (0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0.5 - 1.0 i) == 9.261330313501824245501244453057873152694e-1 - 1.221357263937683325603909865564381489366 i": +Test "Imaginary part of: cacosh (0.5 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0.75 + 1.25 i) == 1.13239363160530819522266333696834467 + 1.11752014915610270578240049553777969 i": +Test "Real part of: cacosh (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 + 1.895456983915074112227925127005564372844e-8 i": +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 1.895456983915074112227925127005564372844e-8 i": +Test "Real part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.171456840272878582596796205397918831268e-8 - 1.895456983915074112227925127005564372844e-8 i": +Test "Imaginary part of: cacosh (0x0.fffffffffffff8p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 + 3.292722539913596233371825532007990724506e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 4.188407771167967636741951941902992986043e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 + 4.188407771167967636741951941902992986043e-10 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 2.472906068161537187835415298076415423459e-4923 - 3.292722539913596233371825532007990724506e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 4.188407771167967636741951941902992986043e-10 i": +Test "Real part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 2.588578361325995866221775673638805081337e-10 - 4.188407771167967636741951941902992986043e-10 i": +Test "Imaginary part of: cacosh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i) == 0.0 + 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 + 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 + 4.391863861910487109445187743978204002614e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i) == 0.0 - 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i) == 8.245504387859737323891843603996428534945e-36 - 3.452669847162035876032494826387364972849e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Real part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i) == 2.714321200917194650737217746780928423385e-4 - 4.391863861910487109445187743978204002614e-4 i": +Test "Imaginary part of: cacosh (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 2.119177303101063432592523199680782317447e-10 i": +Test "Real part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 + 2.119177303101063432592523199680782317447e-10 i": +Test "Imaginary part of: cacosh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 2.119177303101063432592523199680782317447e-10 i": +Test "Real part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i) == 5.116146586219826555037807251857670783420e-10 - 2.119177303101063432592523199680782317447e-10 i": +Test "Imaginary part of: cacosh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 + 0.0 i) == 2.107342425544701550354780375182800088393e-8 + 0.0 i": +Test "Real part of: cacosh (0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 + 2.557178503953494342609835913586108008322e-301 i": +Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 9.590301705980041385828904092662391018164e-9 i": +Test "Real part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 + 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 - 0.0 i) == 2.107342425544701550354780375182800088393e-8 - 0.0 i": +Test "Real part of: cacosh (0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1.fp-1025 i) == 2.107342425544701550354780375182800088393e-8 - 2.557178503953494342609835913586108008322e-301 i": +Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 9.590301705980041385828904092662391018164e-9 i": +Test "Real part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i) == 2.315303644582684770975188768022139415020e-8 - 9.590301705980041385828904092662391018164e-9 i": +Test "Imaginary part of: cacosh (0x1.0000000000001p0 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 2.222118384408546368406374049167636760903e-4 i": +Test "Real part of: cacosh (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 + 2.222118384408546368406374049167636760903e-4 i": +Test "Imaginary part of: cacosh (0x1.000002p0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 2.222118384408546368406374049167636760903e-4 i": +Test "Real part of: cacosh (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i) == 5.364668491573609633134147164031476452679e-4 - 2.222118384408546368406374049167636760903e-4 i": +Test "Imaginary part of: cacosh (0x1.000002p0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Real part of: cacosh (0x1.fp-10 + 1.0 i) == 8.813742198809567991336704287826445879025e-1 + 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-10 - 1.0 i) == 8.813742198809567991336704287826445879025e-1 - 1.569458417435338878318763342108699202986 i": +Test "Real part of: cacosh (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-100 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-100 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691638670687364 i": +Test "Real part of: cacosh (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.0 i) == 8.813735870195430252326093249797923090282e-1 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 + 1.5 i) == 1.194763217287109304111930828519090523536 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0x1.000002p0 i) == 8.813736713132375348727889167749389235161e-1 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 0x1p-23 i) == 1.192092895507809676556842485683592032154e-7 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: cacosh (0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.0 i) == 8.813735870195430252326093249797923090282e-1 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: cacosh (0x1.fp-129 - 1.5 i) == 1.194763217287109304111930828519090523536 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: cacosh (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569917e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: cacosh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-30 + 1.0 i) == 8.813735870195430258081932989769495326854e-1 + 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp-30 - 1.0 i) == 8.813735870195430258081932989769495326854e-1 - 1.570796325518966635014803151387033957091 i": +Test "Real part of: cacosh (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (0x1.fp16383 + 0x1.fp16383 i) == 1.135753137836666928715489992987020363057e4 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: cacosh (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-105 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-105 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639729392766 i": +Test "Real part of: cacosh (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-112 + 0.5 i) == 4.812118250596034474977589134243684231352e-1 + 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-112 - 0.5 i) == 4.812118250596034474977589134243684231352e-1 - 1.570796326794896619231321691639751269838 i": +Test "Real part of: cacosh (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 + 0.5 i) == 4.812118250596059896127318386463676808798e-1 + 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 + 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-23 + 0x1.000002p0 i) == 8.813736713132400470205730751186547909968e-1 + 1.570796242501204621739026081991856762292 i": +Test "Real part of: cacosh (0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-23 - 0.5 i) == 4.812118250596059896127318386463676808798e-1 - 1.570796220170866625230343643673321150378 i": +Test "Real part of: cacosh (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i) == 8.813735448726963984495965873956465777250e-1 - 1.570796242501197085295336701632142060969 i": +Test "Real part of: cacosh (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-23 - 0x1.000002p0 i) == 8.813736713132400470205730751186547909968e-1 - 1.570796242501204621739026081991856762292 i": +Test "Real part of: cacosh (0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 + 0.5 i) == 4.812118250596034474977589134243772428682e-1 + 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-52 - 0.5 i) == 4.812118250596034474977589134243772428682e-1 - 1.570796326794896420628589431857911675917 i": +Test "Real part of: cacosh (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 + 0.5 i) == 4.812118250596034474977589134243684231373e-1 + 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 + 1.570796326794896619154657020805582738025 i": +Test "Real part of: cacosh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 - 0.5 i) == 4.812118250596034474977589134243684231373e-1 - 1.570796326794896619134347701278529840650 i": +Test "Real part of: cacosh (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 8.813735870195430251942769895627079569937e-1 - 1.570796326794896619154657020805582738025 i": +Test "Real part of: cacosh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0.25 i) == 5.097911466811016354623559941115413499164e-1 + 4.890443302710802929202843732146540079124e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0.5 i) == 7.328576759736452608886724437653071523305e-1 + 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Real part of: cacosh (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 + 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 + 0x1.fp-10 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 + 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 + 4.247867097467650115899790787875186617316e-5 i": +Test "Real part of: cacosh (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0.25 i) == 5.097911466811016354623559941115413499164e-1 - 4.890443302710802929202843732146540079124e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Real part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0.5 i) == 7.328576759736452608886724437653071523305e-1 - 6.748888455860063801646649673121744318756e-1 i": +Test "Imaginary part of: cacosh (1.0 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Real part of: cacosh (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i) == 4.350501469856803800217957402220976497152e-2 - 4.349129763101882771258049954181971959031e-2 i": +Test "Imaginary part of: cacosh (1.0 - 0x1.fp-10 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.0 - 0x1.fp-30 i) == 4.247867098745151888768727039216644758847e-5 - 4.247867097467650115899790787875186617316e-5 i": +Test "Real part of: cacosh (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + +0 i) == 0.9624236501192068949955178268487368462704 + +0 i": +Test "Real part of: cacosh (1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 + 4.819934639999230680322935210539402497827e-309 i": +Test "Real part of: cacosh (1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: cacosh (1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 + 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 + 7.282957076134209141226696333885150260319e-4933 i": +Test "Real part of: cacosh (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0 i) == 0.9624236501192068949955178268487368462704 - 0 i": +Test "Real part of: cacosh (1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0x1.fp-1025 i) == 9.624236501192068949955178268487368462704e-1 - 4.819934639999230680322935210539402497827e-309 i": +Test "Real part of: cacosh (1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0x1.fp-129 i) == 9.624236501192068949955178268487368462704e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: cacosh (1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cacosh (1.5 - 0x1.fp-16385 i) == 9.624236501192068949955178268487368462704e-1 - 7.282957076134209141226696333885150260319e-4933 i": +Test "Real part of: cacosh (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # casin -Test "Imaginary part of: casin (+0 + 0.5 i) == +0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.0 i) == +0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 + 1.5 i) == +0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (+0 - 0.5 i) == +0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (+0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.0 i) == +0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (+0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (+0 - 1.5 i) == +0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (+0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 + 0.5 i) == -0 + 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.0 i) == -0 + 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 + 1.5 i) == -0 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0 - 0.5 i) == -0 - 0.4812118250596034474977589134243684231352 i": +Test "Imaginary part of: casin (-0 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.0 i) == -0 - 0.8813735870195430252326093249797923090282 i": +Test "Imaginary part of: casin (-0 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0 - 1.5 i) == -0 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffp0 i) == -0.0 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x1.000002p0 i) == -0.0 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 + 0x1p-23 i) == -0.0 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (-0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffp0 i) == -0.0 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x1.000002p0 i) == -0.0 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.0 - 0x1p-23 i) == -0.0 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (-0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.25 + 1.0 i) == -1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (-0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.25 - 1.0 i) == -1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (-0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-1025 i) == -5.235987755982988730771072305465838140329e-1 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1.fp-16385 i) == -5.235987755982988730771072305465838140329e-1 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (-0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-105 i) == -5.235987755982988730771072305465838140329e-1 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0.5 + 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (-0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 + 0x1p-52 i) == -5.235987755982988730771072305465648369889e-1 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (-0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 + 1.0 i) == -3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (-0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 + 1.0 i) == -3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-1025 i) == -5.235987755982988730771072305465838140329e-1 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i) == -5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1.fp-16385 i) == -5.235987755982988730771072305465838140329e-1 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (-0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-105 i) == -5.235987755982988730771072305465838140329e-1 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-112 i) == -5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0.5 - 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (-0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-23 i) == -5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0.5 - 0x1p-52 i) == -5.235987755982988730771072305465648369889e-1 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (-0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0.5 - 1.0 i) == -3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (-0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0.5 - 1.0 i) == -3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (-0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i) == -1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i) == -1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (-0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == -1.570796326465624365239962068302568888898 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -1.570796326376055842114524927965556247908 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == -1.570796326465624365239962068302568888898 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -1.570796326376055842114524927965556247908 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i) == -1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i) == -1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (-0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (-0x1.0000000000000002p0 + 0x1p-63 i) == -1.570796326582978888921215348380499122131 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1.0000000000000002p0 - 0x1p-63 i) == -1.570796326582978888921215348380499122131 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0.0 i) == -1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1p-52 i) == -1.570796317204594913251280305810847349436 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0.0 i) == -1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1p-52 i) == -1.570796317204594913251280305810847349436 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (-0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.000002p0 + 0x1p-23 i) == -1.570574114956455764594481054234834678422 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (-0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.000002p0 - 0x1p-23 i) == -1.570574114956455764594481054234834678422 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (-0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (-0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i) == -1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (-0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i) == -1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (-0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-100 + 1.0 i) == -1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-100 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i) == -1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-100 - 1.0 i) == -1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-100 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i) == -1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-1000 + 1.0 i) == -1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-1000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i) == -1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1.fp-1000 - 1.0 i) == -1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-1000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i) == -1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1.fp-10000 + 1.0 i) == -6.867047849047171855399183659351043150871e-3011 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-10000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-10000 - 1.0 i) == -6.867047849047171855399183659351043150871e-3011 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-1025 + 1.0 i) == -3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-1025 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i) == -3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i) == -2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: casin (-0x1.fp-1025 - 1.0 i) == -3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-1025 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i) == -3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i) == -2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i) == -2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-129 + 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 0x1p-23 i) == -2.846900380897707329917933005874691056564e-39 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-129 + 1.0 i) == -2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-129 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i) == -2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i) == -1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i) == -2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1.fp-129 - 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0x1.000002p0 i) == -2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 0x1p-23 i) == -2.846900380897707329917933005874691056564e-39 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-129 - 1.0 i) == -2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (-0x1.fp-129 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i) == -2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i) == -1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (-0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == -5.757683115456107044287327268904964422212e-4933 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == -5.757683115456107044287327268904964422212e-4933 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (-0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i) == -1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (-0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i) == -1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (-0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-105 + 0.5 i) == -2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-105 - 0.5 i) == -2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-112 + 0.5 i) == -1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-112 - 0.5 i) == -1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (-0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0.5 i) == -1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 + 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: casin (-0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (-0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0.5 i) == -1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i) == -8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (-0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (-0x1p-23 - 0x1.000002p0 i) == -8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: casin (-0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-52 + 0.5 i) == -1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-52 - 0.5 i) == -1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (-0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0.5 i) == -9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i) == -7.666467083416870406778649849746878368519e-20 + 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0.5 i) == -9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i) == -7.666467083416870406778649849746878368519e-20 - 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 + 0.25 i) == -1.081751996523816326311037318425097434186 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (-1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0.5 i) == -8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 + 0x1.fp-30 i) == -1.570753848123921942730162693731872690232 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (-1.0 - 0.25 i) == -1.081751996523816326311037318425097434186 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (-1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0.5 i) == -8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (-1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i) == -1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.0 - 0x1.fp-30 i) == -1.570753848123921942730162693731872690232 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + +0 i) == -pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + 0x1.fp-129 i) == -1.570796326794896619231321691639751442096 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 + 0x1.fp-16385 i) == -1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0 i) == -pi/2 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (-1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0x1.fp-1025 i) == -1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0x1.fp-129 i) == -1.570796326794896619231321691639751442096 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (-1.5 - 0x1.fp-16385 i) == -1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (-1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffp0 i) == 0.0 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0.0 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x1.000002p0 i) == 0.0 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0.0 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 + 0x1p-23 i) == 0.0 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (0.0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffp0 i) == 0.0 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0.0 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x1.000002p0 i) == 0.0 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0.0 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.0 - 0x1p-23 i) == 0.0 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (0.0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.25 + 1.0 i) == 1.763024327769669304186785666360901026468e-1 + 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (0.25 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.25 - 1.0 i) == 1.763024327769669304186785666360901026468e-1 - 8.924633639033482359562124741744951972772e-1 i": +Test "Imaginary part of: casin (0.25 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-1025 i) == 5.235987755982988730771072305465838140329e-1 + 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 + 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1.fp-16385 i) == 5.235987755982988730771072305465838140329e-1 + 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (0.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-105 i) == 5.235987755982988730771072305465838140329e-1 + 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (0.5 + 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 + 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (0.5 + 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.5 + 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (0.5 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 + 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 + 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 + 0x1p-52 i) == 5.235987755982988730771072305465648369889e-1 + 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (0.5 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 + 1.0 i) == 3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (0.5 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 + 1.0 i) == 3.494390628572132936274118260753699527325e-1 + 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-1025 i) == 5.235987755982988730771072305465838140329e-1 - 6.222508863508420569166420770843207333493e-309 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i) == 5.235987755982988730771072305465838140329e-1 - 3.287317402534702257036015056278368274737e-39 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-129 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1.fp-16385 i) == 5.235987755982988730771072305465838140329e-1 - 9.402257155670418112159334875199821342890e-4933 i": +Test "Imaginary part of: casin (0.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-105 i) == 5.235987755982988730771072305465838140329e-1 - 2.846556599890768890940941645338546615370e-32 i": +Test "Imaginary part of: casin (0.5 - 0x1p-105 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-112 i) == 5.235987755982988730771072305465838140329e-1 - 2.223872343664663196047610660420739543258e-34 i": +Test "Imaginary part of: casin (0.5 - 0x1p-112 i)": double: 1 idouble: 1 -Test "Real part of: casin (0.5 - 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Real part of: casin (0.5 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-23 i) == 5.235987755982934033165770729745469098254e-1 - 1.376510308240943236356088341381173571841e-7 i": +Test "Imaginary part of: casin (0.5 - 0x1p-23 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0.5 - 0x1p-52 i) == 5.235987755982988730771072305465648369889e-1 - 2.563950248511418570403591756798643804971e-16 i": +Test "Imaginary part of: casin (0.5 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.5 - 1.0 i) == 3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Real part of: casin (0.5 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0.5 - 1.0 i) == 3.494390628572132936274118260753699527325e-1 - 9.261330313501824245501244453057873152694e-1 i": +Test "Imaginary part of: casin (0.5 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Real part of: casin (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0.75 + 1.25 i) == 0.453276177638793913448921196101971749 + 1.13239363160530819522266333696834467 i": +Test "Imaginary part of: casin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i) == 1.570796307840326780080580569360500172043 + 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 + 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i) == 1.570796307840326780080580569360500172043 - 1.171456840272878582596796205397918831268e-8 i": +Test "Imaginary part of: casin (0x0.fffffffffffff8p0 - 0x1p-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 1.570796326465624365239962068302568888898 + 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 1.570796326376055842114524927965556247908 + 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 1.570796326465624365239962068302568888898 - 2.472906068161537187835415298076415423459e-4923 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 1.570796326376055842114524927965556247908 - 2.588578361325995866221775673638805081337e-10 i": +Test "Imaginary part of: casin (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i) == 1.570357140408705570520377172865353621698 + 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 + 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i) == 1.570357140408705570520377172865353621698 - 2.714321200917194650737217746780928423385e-4 i": +Test "Imaginary part of: casin (0x0.ffffffp0 - 0x1p-23 i)": float: 2 ifloat: 2 -Test "Imaginary part of: casin (0x1.0000000000000002p0 + 0x1p-63 i) == 1.570796326582978888921215348380499122131 + 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1.0000000000000002p0 - 0x1p-63 i) == 1.570796326582978888921215348380499122131 - 5.116146586219826555037807251857670783420e-10 i": +Test "Imaginary part of: casin (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: casin (0x1.0000000000001p0 + 0.0 i) == 1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 + 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1p-52 i) == 1.570796317204594913251280305810847349436 + 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 + 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 - 0.0 i) == 1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 - 2.107342425544701550354780375182800088393e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1p-52 i) == 1.570796317204594913251280305810847349436 - 2.315303644582684770975188768022139415020e-8 i": +Test "Imaginary part of: casin (0x1.0000000000001p0 - 0x1p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.000002p0 + 0x1p-23 i) == 1.570574114956455764594481054234834678422 + 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (0x1.000002p0 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.000002p0 - 0x1p-23 i) == 1.570574114956455764594481054234834678422 - 5.364668491573609633134147164031476452679e-4 i": +Test "Imaginary part of: casin (0x1.000002p0 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i) == 1.337909359557740912558349531052239112857e-3 + 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Real part of: casin (0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i) == 1.337909359557740912558349531052239112857e-3 - 8.813742198809567991336704287826445879025e-1 i": +Test "Imaginary part of: casin (0x1.fp-10 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-100 + 1.0 i) == 1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-100 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i) == 1.080754735021050612990719608916167354321e-30 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-100 - 1.0 i) == 1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-100 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i) == 1.080754735021050612990719608916167354321e-30 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-100 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-1000 + 1.0 i) == 1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-1000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i) == 1.278589251976747242280879285935084814093e-301 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 + 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1.fp-1000 - 1.0 i) == 1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-1000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i) == 1.278589251976747242280879285935084814093e-301 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1000 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1.fp-10000 + 1.0 i) == 6.867047849047171855399183659351043150871e-3011 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-10000 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-10000 - 1.0 i) == 6.867047849047171855399183659351043150871e-3011 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-10000 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-1025 + 1.0 i) == 3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-1025 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i) == 3.810492908885321743133304375216617626230e-309 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i) == 2.989196569048182929051881765490354365918e-309 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 + 1.5 i)": double: 1 idouble: 1 -Test "Real part of: casin (0x1.fp-1025 - 1.0 i) == 3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-1025 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i) == 3.810492908885321743133304375216617626230e-309 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i) == 2.989196569048182929051881765490354365918e-309 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-1025 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i) == 2.546345110742945032959687790021055102355e-39 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-129 + 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 + 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 0x1p-23 i) == 2.846900380897707329917933005874691056564e-39 + 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (0x1.fp-129 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-129 + 1.0 i) == 2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-129 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i) == 2.013062564695348242280482517399205554874e-39 + 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i) == 1.579176199917649005841160751101628985741e-39 + 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 + 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i) == 2.546345110742945032959687790021055102355e-39 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1.fp-129 - 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Real part of: casin (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0x1.000002p0 i) == 2.013062444707472738895109955455676357057e-39 - 8.813736713132375348727889167749389235161e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 0x1p-23 i) == 2.846900380897707329917933005874691056564e-39 - 1.192092895507809676556842485683592032154e-7 i": +Test "Imaginary part of: casin (0x1.fp-129 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-129 - 1.0 i) == 2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Real part of: casin (0x1.fp-129 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i) == 2.013062564695348242280482517399205554874e-39 - 8.813735870195430252326093249797923090282e-1 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i) == 1.579176199917649005841160751101628985741e-39 - 1.194763217287109304111930828519090523536 i": +Test "Imaginary part of: casin (0x1.fp-129 - 1.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 5.757683115456107044287327268904964422212e-4933 + 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 5.757683115456107044287327268904964422212e-4933 - 8.813735870195430251942769895627079569917e-1 i": +Test "Imaginary part of: casin (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i) == 1.275929984216518540252717485007112529021e-9 + 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Real part of: casin (0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i) == 1.275929984216518540252717485007112529021e-9 - 8.813735870195430258081932989769495326854e-1 i": +Test "Imaginary part of: casin (0x1.fp-30 - 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i) == 7.853981633974483096156608458198757210493e-1 + 7.107906849659093345062145442726115449315e2 i": +Test "Imaginary part of: casin (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i) == 7.853981633974483096156608458198757210493e-1 + 8.973081118419833726837456344608533993585e1 i": +Test "Imaginary part of: casin (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Imaginary part of: casin (0x1.fp16383 + 0x1.fp16383 i) == 7.853981633974483096156608458198757210493e-1 + 1.135753137836666928715489992987020363057e4 i": +Test "Imaginary part of: casin (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-105 + 0.5 i) == 2.204933261082751447436996198490110245167e-32 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-105 - 0.5 i) == 2.204933261082751447436996198490110245167e-32 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-105 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-112 + 0.5 i) == 1.722604110220899568310153280070398629037e-34 + 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-112 - 0.5 i) == 1.722604110220899568310153280070398629037e-34 - 4.812118250596034474977589134243684231352e-1 i": +Test "Imaginary part of: casin (0x1p-112 - 0.5 i)": float: 1 ifloat: 1 -Test "Real part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 + 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0.5 i) == 1.066240299940009780479664302917201696886e-7 + 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 + 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 + 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 + 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 + 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: casin (0x1p-23 + 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Real part of: casin (0x1p-23 - 0.5 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0.5 i) == 1.066240299940009780479664302917201696886e-7 - 4.812118250596059896127318386463676808798e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i) == 8.429369953393598499000760938112968755257e-8 - 8.813735448726963984495965873956465777250e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0x0.ffffffp0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Real part of: casin (0x1p-23 - 0x1.000002p0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casin (0x1p-23 - 0x1.000002p0 i) == 8.429369199749229560964789467980644296420e-8 - 8.813736713132400470205730751186547909968e-1 i": +Test "Imaginary part of: casin (0x1p-23 - 0x1.000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-52 + 0.5 i) == 1.986027322597818397661816253158024383707e-16 + 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-52 - 0.5 i) == 1.986027322597818397661816253158024383707e-16 - 4.812118250596034474977589134243772428682e-1 i": +Test "Imaginary part of: casin (0x1p-52 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 + 0.5 i) == 9.697399036122160144833087173623140436413e-20 + 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 + 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 + 0x1.0000000000000002p0 i) == 7.666467083416870406778649849746878368519e-20 + 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 - 0.5 i) == 9.697399036122160144833087173623140436413e-20 - 4.812118250596034474977589134243684231373e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Real part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 7.666467083416870407402049869781566856442e-20 - 8.813735870195430251942769895627079569937e-1 i": +Test "Imaginary part of: casin (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (0x1p-63 - 0x1.0000000000000002p0 i) == 7.666467083416870406778649849746878368519e-20 - 8.813735870195430253092739958139610131001e-1 i": +Test "Real part of: casin (0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 + 0.25 i) == 1.081751996523816326311037318425097434186 + 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (1.0 + 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0.5 i) == 8.959074812088902390666567243275770102229e-1 + 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 + 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 + 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 + 0x1.fp-30 i) == 1.570753848123921942730162693731872690232 + 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casin (1.0 - 0.25 i) == 1.081751996523816326311037318425097434186 - 5.097911466811016354623559941115413499164e-1 i": +Test "Real part of: casin (1.0 - 0.25 i)": double: 1 idouble: 1 -Test "Real part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Real part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0.5 i) == 8.959074812088902390666567243275770102229e-1 - 7.328576759736452608886724437653071523305e-1 i": +Test "Imaginary part of: casin (1.0 - 0.5 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i) == 1.527305029163877791518741192097931722508 - 4.350501469856803800217957402220976497152e-2 i": +Test "Imaginary part of: casin (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.0 - 0x1.fp-30 i) == 1.570753848123921942730162693731872690232 - 4.247867098745151888768727039216644758847e-5 i": +Test "Imaginary part of: casin (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + +0 i) == pi/2 + 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 + +0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + 0x1.fp-129 i) == 1.570796326794896619231321691639751442096 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 + 0x1.fp-16385 i) == 1.570796326794896619231321691639751442099 + 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0 i) == pi/2 - 0.9624236501192068949955178268487368462704 i": +Test "Imaginary part of: casin (1.5 - 0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0x1.fp-1025 i) == 1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0x1.fp-129 i) == 1.570796326794896619231321691639751442096 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casin (1.5 - 0x1.fp-16385 i) == 1.570796326794896619231321691639751442099 - 9.624236501192068949955178268487368462704e-1 i": +Test "Imaginary part of: casin (1.5 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 # casinh -Test "Real part of: casinh (+0 + 1.5 i) == 0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (+0 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (+0 - 1.5 i) == 0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (+0 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 + 1.5 i) == -0.9624236501192068949955178268487368462704 + pi/2 i": +Test "Real part of: casinh (-0 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0 - 1.5 i) == -0.9624236501192068949955178268487368462704 - pi/2 i": +Test "Real part of: casinh (-0 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.0 + 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.0 - 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.25 + 1.0 i) == -5.097911466811016354623559941115413499164e-1 + 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (-0.25 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0.25 - 1.0 i) == -5.097911466811016354623559941115413499164e-1 - 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (-0.25 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0.5 + +0 i) == -0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (-0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 + 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 + 0x1p-52 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 + 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.5 + 1.0 i) == -7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0 i) == -0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (-0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1.fp-129 i) == -4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (-0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-105 i) == -4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (-0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-112 i) == -4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (-0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (-0.5 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i) == -4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (-0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0.5 - 0x1p-52 i) == -4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (-0.5 - 0x1p-52 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 0x1p-63 i) == -4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (-0.5 - 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0.5 - 1.0 i) == -7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (-0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0.0 i) == -8.813735870195430251942769895627079569917e-1 + 0.0 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == -8.813735870195430251942769895627079569917e-1 + 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0.0 i) == -8.813735870195430251942769895627079569917e-1 - 0.0 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == -8.813735870195430251942769895627079569917e-1 - 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i) == -8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (-0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i) == -8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (-0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i) == -8.813735870195430253092739958139610131001e-1 + 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (-0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i) == -8.813735870195430253092739958139610131001e-1 - 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (-0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000002p0 + 0.0 i) == -8.813736713132375348727889167749389235161e-1 + 0.0 i": +Test "Real part of: casinh (-0x1.000002p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000002p0 + 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (-0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000002p0 + 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Real part of: casinh (-0x1.000002p0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.000002p0 - 0.0 i) == -8.813736713132375348727889167749389235161e-1 - 0.0 i": +Test "Real part of: casinh (-0x1.000002p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000002p0 - 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (-0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1.fp-129 i) == -8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.000002p0 - 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Real part of: casinh (-0x1.000002p0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i) == -8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (-0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-0x1.fp-10 + 1.0 i) == -4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (-0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-10 - 1.0 i) == -4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (-0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 + 0.5 i) == -6.222508863508420569166420770843207333493e-309 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 + 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 + 1.5 i) == -9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 - 0.5 i) == -6.222508863508420569166420770843207333493e-309 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 - 0x1.0000000000001p0 i) == -2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-1025 - 1.5 i) == -9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-1025 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 + 0.5 i) == -3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 + 1.5 i) == -9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (-0x1.fp-129 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 - 0.5 i) == -3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-129 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-129 - 1.5 i) == -9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (-0x1.fp-129 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 + 0.5 i) == -9.402257155670418112159334875199821342890e-4933 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == -2.472906068161537187835415298076415423459e-4923 + 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (-0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 + 1.5 i) == -9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 - 0.5 i) == -9.402257155670418112159334875199821342890e-4933 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == -2.472906068161537187835415298076415423459e-4923 - 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (-0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-16385 - 1.5 i) == -9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (-0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-30 + 1.0 i) == -4.247867098745151888768727039216644758847e-5 + 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (-0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1.fp-30 - 1.0 i) == -4.247867098745151888768727039216644758847e-5 - 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (-0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-105 + 0.5 i) == -2.846556599890768890940941645338546615370e-32 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-105 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-105 - 0.5 i) == -2.846556599890768890940941645338546615370e-32 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-105 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-112 + 0.5 i) == -2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-112 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-112 - 0.5 i) == -2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (-0x1p-112 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0.0 i) == -1.192092895507809676556842485683592032154e-7 + 0.0 i": +Test "Real part of: casinh (-0x1p-23 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0.5 i) == -1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1p-23 + 0.5 i) == -1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (-0x1p-23 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 + 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Real part of: casinh (-0x1p-23 + 0x1.000002p0 i) == -5.364668491573609633134147164031476452679e-4 + 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (-0x1p-23 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0x1p-23 + 0x1.fp-129 i) == -1.192092895507809676556842485683592032154e-7 + 2.846900380897707329917933005874691056564e-39 i": +Test "Real part of: casinh (-0x1p-23 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0.0 i) == -1.192092895507809676556842485683592032154e-7 - 0.0 i": +Test "Real part of: casinh (-0x1p-23 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0.5 i) == -1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (-0x1p-23 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-0x1p-23 - 0.5 i) == -1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (-0x1p-23 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i) == -2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (-0x1p-23 - 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Real part of: casinh (-0x1p-23 - 0x1.000002p0 i) == -5.364668491573609633134147164031476452679e-4 - 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (-0x1p-23 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-0x1p-23 - 0x1.fp-129 i) == -1.192092895507809676556842485683592032154e-7 - 2.846900380897707329917933005874691056564e-39 i": +Test "Real part of: casinh (-0x1p-23 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0.5 i) == -2.563950248511418570403591756798643804971e-16 + 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (-0x1p-52 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 + 0x1.0000000000001p0 i) == -2.315303644582684770975188768022139415020e-8 + 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (-0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0.5 i) == -2.563950248511418570403591756798643804971e-16 - 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (-0x1p-52 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i) == -1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (-0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-52 - 0x1.0000000000001p0 i) == -2.315303644582684770975188768022139415020e-8 - 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (-0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i) == -2.588578361325995866221775673638805081337e-10 + 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (-0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 + 0x1.0000000000000002p0 i) == -5.116146586219826555037807251857670783420e-10 + 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (-0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i) == -2.588578361325995866221775673638805081337e-10 - 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (-0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-0x1p-63 - 0x1.0000000000000002p0 i) == -5.116146586219826555037807251857670783420e-10 - 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (-0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (-1.0 + +0 i) == -0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (-1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0.25 i) == -8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (-1.0 + 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0.5 i) == -9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0.5 i) == -9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (-1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10000 i) == -8.813735870195430252326093249797923090282e-1 + 6.867047849047171855399183659351043150871e-3011 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (-1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0 i) == -0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (-1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0.25 i) == -8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (-1.0 - 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0.5 i) == -9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (-1.0 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0.5 i) == -9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (-1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i) == -8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-100 i) == -8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-1000 i) == -8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10000 i) == -8.813735870195430252326093249797923090282e-1 - 6.867047849047171855399183659351043150871e-3011 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-1025 i) == -8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-129 i) == -8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (-1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i) == -8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (-1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (-1.5 + +0 i) == -1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (-1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 + 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0 i) == -1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (-1.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i) == -1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-1.5 - 0x1.fp-129 i) == -1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (-1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (-2 - 3 i) == -1.9686379257930962917886650952454982 - 0.96465850440760279204541105949953237 i": +Test "Real part of: casinh (-2 - 3 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.0 + 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0.0 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.0 - 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0.0 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.25 + 1.0 i) == 5.097911466811016354623559941115413499164e-1 + 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (0.25 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0.25 - 1.0 i) == 5.097911466811016354623559941115413499164e-1 - 1.081751996523816326311037318425097434186 i": +Test "Imaginary part of: casinh (0.25 - 1.0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0.5 + +0 i) == 0.4812118250596034474977589134243684231352 + +0 i": +Test "Real part of: casinh (0.5 + +0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 + 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 + 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 + 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 + 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 + 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 + 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 + 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 + 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 + 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0.5 + 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 + 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 + 0x1p-52 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 + 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 + 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.5 + 1.0 i) == 7.328576759736452608886724437653071523305e-1 + 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0 i) == 0.4812118250596034474977589134243684231352 - 0 i": +Test "Real part of: casinh (0.5 - 0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1.fp-129 i) == 4.812118250596034474977589134243684231352e-1 - 2.546345110742945032959687790021055102355e-39 i": +Test "Real part of: casinh (0.5 - 0x1.fp-129 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-105 i) == 4.812118250596034474977589134243684231352e-1 - 2.204933261082751447436996198490110245167e-32 i": +Test "Real part of: casinh (0.5 - 0x1p-105 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-112 i) == 4.812118250596034474977589134243684231352e-1 - 1.722604110220899568310153280070398629037e-34 i": +Test "Real part of: casinh (0.5 - 0x1p-112 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Real part of: casinh (0.5 - 0x1p-23 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.5 - 0x1p-23 i) == 4.812118250596059896127318386463676808798e-1 - 1.066240299940009780479664302917201696886e-7 i": +Test "Imaginary part of: casinh (0.5 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0.5 - 0x1p-52 i) == 4.812118250596034474977589134243772428682e-1 - 1.986027322597818397661816253158024383707e-16 i": +Test "Real part of: casinh (0.5 - 0x1p-52 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 0x1p-63 i) == 4.812118250596034474977589134243684231373e-1 - 9.697399036122160144833087173623140436413e-20 i": +Test "Real part of: casinh (0.5 - 0x1p-63 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Real part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0.5 - 1.0 i) == 7.328576759736452608886724437653071523305e-1 - 8.959074812088902390666567243275770102229e-1 i": +Test "Imaginary part of: casinh (0.5 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Real part of: casinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: casinh (0.75 + 1.25 i) == 1.03171853444778027336364058631006594 + 0.911738290968487636358489564316731207 i": +Test "Imaginary part of: casinh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0.0 i) == 8.813735870195430251942769895627079569917e-1 + 0.0 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i) == 8.813735870195430251942769895627079569917e-1 + 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 + 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0.0 i) == 8.813735870195430251942769895627079569917e-1 - 0.0 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i) == 8.813735870195430251942769895627079569917e-1 - 5.757683115456107044287327268904964422212e-4933 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1.fp-16385 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Real part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i) == 8.813735870195430251942769895627079569937e-1 - 7.666467083416870407402049869781566856442e-20 i": +Test "Imaginary part of: casinh (0x0.ffffffffffffffffp0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 + 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 + 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i) == 8.813735448726963984495965873956465777250e-1 - 8.429369953393598499000760938112968755257e-8 i": +Test "Real part of: casinh (0x0.ffffffp0 - 0x1p-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i) == 8.813735870195430253092739958139610131001e-1 + 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (0x1.0000000000000002p0 + 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i) == 8.813735870195430253092739958139610131001e-1 - 7.666467083416870406778649849746878368519e-20 i": +Test "Imaginary part of: casinh (0x1.0000000000000002p0 - 0x1p-63 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000002p0 + 0.0 i) == 8.813736713132375348727889167749389235161e-1 + 0.0 i": +Test "Real part of: casinh (0x1.000002p0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000002p0 + 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 + 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 + 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (0x1.000002p0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000002p0 + 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Real part of: casinh (0x1.000002p0 + 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 + 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 + 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1.000002p0 - 0.0 i) == 8.813736713132375348727889167749389235161e-1 - 0.0 i": +Test "Real part of: casinh (0x1.000002p0 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000002p0 - 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Real part of: casinh (0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 - 0x1.fp-129 i) == 8.813736713132375348727889167749389235161e-1 - 2.013062444707472738895109955455676357057e-39 i": +Test "Imaginary part of: casinh (0x1.000002p0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.000002p0 - 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Real part of: casinh (0x1.000002p0 - 0x1p-23 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i) == 8.813736713132400470205730751186547909968e-1 - 8.429369199749229560964789467980644296420e-8 i": +Test "Imaginary part of: casinh (0x1.000002p0 - 0x1p-23 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (0x1.fp-10 + 1.0 i) == 4.350501469856803800217957402220976497152e-2 + 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (0x1.fp-10 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-10 - 1.0 i) == 4.350501469856803800217957402220976497152e-2 - 1.527305029163877791518741192097931722508 i": +Test "Real part of: casinh (0x1.fp-10 - 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 + 0.5 i) == 6.222508863508420569166420770843207333493e-309 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-1025 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 + 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 + 1.5 i) == 9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 - 0.5 i) == 6.222508863508420569166420770843207333493e-309 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-1025 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 - 0x1.0000000000001p0 i) == 2.107342425544701550354780375182800088393e-8 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-1025 - 1.5 i) == 9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-1025 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 + 0.5 i) == 3.287317402534702257036015056278368274737e-39 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 + 1.5 i) == 9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (0x1.fp-129 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 - 0.5 i) == 3.287317402534702257036015056278368274737e-39 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-129 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-129 - 1.5 i) == 9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442096 i": +Test "Real part of: casinh (0x1.fp-129 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 + 0.5 i) == 9.402257155670418112159334875199821342890e-4933 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-16385 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i) == 2.472906068161537187835415298076415423459e-4923 + 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (0x1.fp-16385 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 + 1.5 i) == 9.624236501192068949955178268487368462704e-1 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-16385 + 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 - 0.5 i) == 9.402257155670418112159334875199821342890e-4933 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1.fp-16385 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i) == 2.472906068161537187835415298076415423459e-4923 - 1.570796326465624365239962068302568888898 i": +Test "Real part of: casinh (0x1.fp-16385 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-16385 - 1.5 i) == 9.624236501192068949955178268487368462704e-1 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: casinh (0x1.fp-16385 - 1.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-30 + 1.0 i) == 4.247867098745151888768727039216644758847e-5 + 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (0x1.fp-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp-30 - 1.0 i) == 4.247867098745151888768727039216644758847e-5 - 1.570753848123921942730162693731872690232 i": +Test "Real part of: casinh (0x1.fp-30 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i) == 7.107906849659093345062145442726115449315e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i) == 8.973081118419833726837456344608533993585e1 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1.fp16383 + 0x1.fp16383 i) == 1.135753137836666928715489992987020363057e4 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: casinh (0x1.fp16383 + 0x1.fp16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-105 + 0.5 i) == 2.846556599890768890940941645338546615370e-32 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-105 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-105 - 0.5 i) == 2.846556599890768890940941645338546615370e-32 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-105 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-112 + 0.5 i) == 2.223872343664663196047610660420739543258e-34 + 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-112 + 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-112 - 0.5 i) == 2.223872343664663196047610660420739543258e-34 - 5.235987755982988730771072305465838140329e-1 i": +Test "Real part of: casinh (0x1p-112 - 0.5 i)": double: 1 idouble: 1 -Test "Real part of: casinh (0x1p-23 + 0.0 i) == 1.192092895507809676556842485683592032154e-7 + 0.0 i": +Test "Real part of: casinh (0x1p-23 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 + 0.5 i) == 1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 + 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1p-23 + 0.5 i) == 1.376510308240943236356088341381173571841e-7 + 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (0x1p-23 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 + 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 + 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Real part of: casinh (0x1p-23 + 0x1.000002p0 i) == 5.364668491573609633134147164031476452679e-4 + 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (0x1p-23 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0x1p-23 + 0x1.fp-129 i) == 1.192092895507809676556842485683592032154e-7 + 2.846900380897707329917933005874691056564e-39 i": +Test "Real part of: casinh (0x1p-23 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0.0 i) == 1.192092895507809676556842485683592032154e-7 - 0.0 i": +Test "Real part of: casinh (0x1p-23 - 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0.5 i) == 1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Real part of: casinh (0x1p-23 - 0.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (0x1p-23 - 0.5 i) == 1.376510308240943236356088341381173571841e-7 - 5.235987755982934033165770729745469098254e-1 i": +Test "Imaginary part of: casinh (0x1p-23 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i) == 2.714321200917194650737217746780928423385e-4 - 1.570357140408705570520377172865353621698 i": +Test "Real part of: casinh (0x1p-23 - 0x0.ffffffp0 i)": float: 2 ifloat: 2 -Test "Real part of: casinh (0x1p-23 - 0x1.000002p0 i) == 5.364668491573609633134147164031476452679e-4 - 1.570574114956455764594481054234834678422 i": +Test "Real part of: casinh (0x1p-23 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (0x1p-23 - 0x1.fp-129 i) == 1.192092895507809676556842485683592032154e-7 - 2.846900380897707329917933005874691056564e-39 i": +Test "Real part of: casinh (0x1p-23 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 + 0.5 i) == 2.563950248511418570403591756798643804971e-16 + 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (0x1p-52 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 + 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 + 0x1.0000000000001p0 i) == 2.315303644582684770975188768022139415020e-8 + 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (0x1p-52 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 - 0.5 i) == 2.563950248511418570403591756798643804971e-16 - 5.235987755982988730771072305465648369889e-1 i": +Test "Real part of: casinh (0x1p-52 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i) == 1.171456840272878582596796205397918831268e-8 - 1.570796307840326780080580569360500172043 i": +Test "Real part of: casinh (0x1p-52 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-52 - 0x1.0000000000001p0 i) == 2.315303644582684770975188768022139415020e-8 - 1.570796317204594913251280305810847349436 i": +Test "Real part of: casinh (0x1p-52 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i) == 2.588578361325995866221775673638805081337e-10 + 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (0x1p-63 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 + 0x1.0000000000000002p0 i) == 5.116146586219826555037807251857670783420e-10 + 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (0x1p-63 + 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i) == 2.588578361325995866221775673638805081337e-10 - 1.570796326376055842114524927965556247908 i": +Test "Real part of: casinh (0x1p-63 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (0x1p-63 - 0x1.0000000000000002p0 i) == 5.116146586219826555037807251857670783420e-10 - 1.570796326582978888921215348380499122131 i": +Test "Real part of: casinh (0x1p-63 - 0x1.0000000000000002p0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: casinh (1.0 + +0 i) == 0.8813735870195430252326093249797923090282 + +0 i": +Test "Real part of: casinh (1.0 + +0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0.25 i) == 8.924633639033482359562124741744951972772e-1 + 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (1.0 + 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0.5 i) == 9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 + 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0.5 i) == 9.261330313501824245501244453057873152694e-1 + 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (1.0 + 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 + 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 + 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 + 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 + 1.080754735021050612990719608916167354321e-30 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 + 1.278589251976747242280879285935084814093e-301 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-10000 i) == 8.813735870195430252326093249797923090282e-1 + 6.867047849047171855399183659351043150871e-3011 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 + 3.810492908885321743133304375216617626230e-309 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 + 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 + 2.013062564695348242280482517399205554874e-39 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 + 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 + 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (1.0 + 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0 i) == 0.8813735870195430252326093249797923090282 - 0 i": +Test "Real part of: casinh (1.0 - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0.25 i) == 8.924633639033482359562124741744951972772e-1 - 1.763024327769669304186785666360901026468e-1 i": +Test "Real part of: casinh (1.0 - 0.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0.5 i) == 9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Real part of: casinh (1.0 - 0.5 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0.5 i) == 9.261330313501824245501244453057873152694e-1 - 3.494390628572132936274118260753699527325e-1 i": +Test "Imaginary part of: casinh (1.0 - 0.5 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Real part of: casinh (1.0 - 0x1.fp-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i) == 8.813742198809567991336704287826445879025e-1 - 1.337909359557740912558349531052239112857e-3 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-10 i)": float: 1 ifloat: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Real part of: casinh (1.0 - 0x1.fp-100 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-100 i) == 8.813735870195430252326093249797923090282e-1 - 1.080754735021050612990719608916167354321e-30 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1000 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-1000 i) == 8.813735870195430252326093249797923090282e-1 - 1.278589251976747242280879285935084814093e-301 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-1000 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-10000 i) == 8.813735870195430252326093249797923090282e-1 - 6.867047849047171855399183659351043150871e-3011 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-10000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Real part of: casinh (1.0 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-1025 i) == 8.813735870195430252326093249797923090282e-1 - 3.810492908885321743133304375216617626230e-309 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-1025 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Real part of: casinh (1.0 - 0x1.fp-129 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-129 i) == 8.813735870195430252326093249797923090282e-1 - 2.013062564695348242280482517399205554874e-39 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-129 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Real part of: casinh (1.0 - 0x1.fp-30 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i) == 8.813735870195430258081932989769495326854e-1 - 1.275929984216518540252717485007112529021e-9 i": +Test "Imaginary part of: casinh (1.0 - 0x1.fp-30 i)": ildouble: 1 ldouble: 1 -Test "Real part of: casinh (1.5 + +0 i) == 1.194763217287109304111930828519090523536 + +0 i": +Test "Real part of: casinh (1.5 + +0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 + 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 + 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 + 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 + 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 + 0x1.fp-129 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0 i) == 1.194763217287109304111930828519090523536 - 0 i": +Test "Real part of: casinh (1.5 - 0 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-1025 i) == 1.194763217287109304111930828519090523536 - 2.989196569048182929051881765490354365918e-309 i": +Test "Real part of: casinh (1.5 - 0x1.fp-1025 i)": double: 1 idouble: 1 -Test "Real part of: casinh (1.5 - 0x1.fp-129 i) == 1.194763217287109304111930828519090523536 - 1.579176199917649005841160751101628985741e-39 i": +Test "Real part of: casinh (1.5 - 0x1.fp-129 i)": double: 1 idouble: 1 # catan -Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i) == -7.853981633974482679822974223765039144191e-1 + 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (-0x0.fffffffffffff8p0 + 0x1p-27 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x0.ffffffffffffffffp0 + 0x1p-33 i) == -7.853981633974483095919439232967553115548e-1 + 5.820766091346740722958646680334721192083e-11 i": +Test "Imaginary part of: catan (-0x0.ffffffffffffffffp0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i) == -7.853981373204155542484315721351697277336e-1 + 6.103515973639646453881721999956617260502e-5 i": +Test "Imaginary part of: catan (-0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1.0000000000001p0 + 0x1p-27 i) == -7.853981633974484345157511161499711112683e-1 + 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (-0x1.0000000000001p0 + 0x1p-27 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.0000000000001p0 - 0x1p-27 i) == -7.853981633974484345157511161499711112683e-1 - 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (-0x1.0000000000001p0 - 0x1p-27 i)": double: 1 idouble: 1 -Test "Real part of: catan (-0x1.000002p0 + 0x1p-126 i) == -7.853982230020895322927482174768220815493e-1 + 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (-0x1.000002p0 + 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000002p0 + 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 + 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000002p0 - 0x1p-126 i) == -7.853982230020895322927482174768220815493e-1 - 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (-0x1.000002p0 - 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1.000002p0 - 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i) == -7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Imaginary part of: catan (-0x1.000002p0 - 0x1p-13 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (-0x1.3p-73 + 1.0 i) == -7.853981633974483096156922786831527361009e-1 + 2.556052055225464683726753902092495938633e1 i": +Test "Imaginary part of: catan (-0x1.3p-73 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.3p-73 - 1.0 i) == -7.853981633974483096156922786831527361009e-1 - 2.556052055225464683726753902092495938633e1 i": +Test "Imaginary part of: catan (-0x1.3p-73 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i) == -1.570796326794896619231321691639751442099 + 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (-0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i) == -1.570796326794896619231321691639751442099 - 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (-0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i) == -1.570796326794896619231321691639751442097 + 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (-0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i) == -1.570796326794896619231321691639751442097 - 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (-0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i) == -7.853981633974483096156608458198757210493e-1 + 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (-0x1p-1020 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i) == -7.853981633974483096156608458198757210493e-1 - 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (-0x1p-1020 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-1022 + 0x0.ffffffffffffffffp0 i) == -2.052268400649188124723641491045245971623e-289 + 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (-0x1p-1022 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-1022 - 0x0.ffffffffffffffffp0 i) == -2.052268400649188124723641491045245971623e-289 - 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (-0x1p-1022 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1p-13 + 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 + 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (-0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 + 1.0 i) == -7.854286809755354140031716771044626356262e-1 + 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (-0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 - 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-13 - 0x1.000002p0 i) == -7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Imaginary part of: catan (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-13 - 1.0 i) == -7.854286809755354140031716771044626356262e-1 - 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (-0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-16382 + 0x0.ffffffffffffffffp0 i) == -3.100992811520163369065387859792822623745e-4913 + 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (-0x1p-16382 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-16382 - 0x0.ffffffffffffffffp0 i) == -3.100992811520163369065387859792822623745e-4913 - 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (-0x1p-16382 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1p-27 + 1.0 i) == -7.853981652600934588466178684534110069553e-1 + 9.704060527839234335310696652368086117807 i": +Test "Real part of: catan (-0x1p-27 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-27 - 1.0 i) == -7.853981652600934588466178684534110069553e-1 - 9.704060527839234335310696652368086117807 i": +Test "Real part of: catan (-0x1p-27 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-33 + 0x0.ffffffffffffffffp0 i) == -7.853981631937214964185249205444919953948e-1 + 1.178350206951907026002603046195591193050e1 i": +Test "Imaginary part of: catan (-0x1p-33 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1p-33 + 1.0 i) == -7.853981634265521400723945494331241018449e-1 + 1.178350206951907026009379309773625595762e1 i": +Test "Real part of: catan (-0x1p-33 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-33 - 0x0.ffffffffffffffffp0 i) == -7.853981631937214964185249205444919953948e-1 - 1.178350206951907026002603046195591193050e1 i": +Test "Imaginary part of: catan (-0x1p-33 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-0x1p-33 - 1.0 i) == -7.853981634265521400723945494331241018449e-1 - 1.178350206951907026009379309773625595762e1 i": +Test "Real part of: catan (-0x1p-33 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-54 + 1.0 i) == -7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Real part of: catan (-0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-54 + 1.0 i) == -7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (-0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-54 - 1.0 i) == -7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Real part of: catan (-0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-54 - 1.0 i) == -7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (-0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-57 + 1.0 i) == -7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Real part of: catan (-0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-57 + 1.0 i) == -7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (-0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-0x1p-57 - 1.0 i) == -7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Real part of: catan (-0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-57 - 1.0 i) == -7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (-0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-0x1p-64 + 1.0 i) == -7.853981633974483096292133729759445264744e-1 + 2.252728336819822255606004394739073846245e1 i": +Test "Imaginary part of: catan (-0x1p-64 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (-0x1p-64 - 1.0 i) == -7.853981633974483096292133729759445264744e-1 - 2.252728336819822255606004394739073846245e1 i": +Test "Imaginary part of: catan (-0x1p-64 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-1.0 + 0x1p-13 i) == -7.853981671227386080775748393881580082970e-1 + 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (-1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 + 0x1p-27 i) == -7.853981633974483234934486536343324763447e-1 + 3.725290298461914028034141143623846306386e-9 i": +Test "Real part of: catan (-1.0 + 0x1p-27 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 + 0x1p-33 i) == -7.853981633974483096190489776088929224056e-1 + 5.820766091346740722643102318246316469910e-11 i": +Test "Real part of: catan (-1.0 + 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 + 0x1p-54 i) == -7.853981633974483096156608458198764914213e-1 + 2.775557561562891351059079170227049355775e-17 i": +Test "Real part of: catan (-1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 + 0x1p-57 i) == -7.853981633974483096156608458198757330864e-1 + 3.469446951953614188823848962783813448721e-18 i": +Test "Real part of: catan (-1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-1.0 + 0x1p-64 i) == -7.853981633974483096156608458198757210500e-1 + 2.710505431213761085018632002174854278563e-20 i": +Test "Imaginary part of: catan (-1.0 + 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-1.0 - 0x1p-13 i) == -7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (-1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-1.0 - 0x1p-13 i) == -7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Imaginary part of: catan (-1.0 - 0x1p-13 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-1.0 - 0x1p-27 i) == -7.853981633974483234934486536343324763447e-1 - 3.725290298461914028034141143623846306386e-9 i": +Test "Real part of: catan (-1.0 - 0x1p-27 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 - 0x1p-33 i) == -7.853981633974483096190489776088929224056e-1 - 5.820766091346740722643102318246316469910e-11 i": +Test "Real part of: catan (-1.0 - 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 - 0x1p-54 i) == -7.853981633974483096156608458198764914213e-1 - 2.775557561562891351059079170227049355775e-17 i": +Test "Real part of: catan (-1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catan (-1.0 - 0x1p-57 i) == -7.853981633974483096156608458198757330864e-1 - 3.469446951953614188823848962783813448721e-18 i": +Test "Real part of: catan (-1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (-1.0 - 0x1p-64 i) == -7.853981633974483096156608458198757210500e-1 - 2.710505431213761085018632002174854278563e-20 i": +Test "Imaginary part of: catan (-1.0 - 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Real part of: catan (-2 - 3 i)": float: 3 ifloat: 3 -Test "Imaginary part of: catan (-2 - 3 i) == -1.4099210495965755225306193844604208 - 0.22907268296853876629588180294200276 i": +Test "Imaginary part of: catan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: catan (0.75 + 1.25 i) == 1.10714871779409050301706546017853704 + 0.549306144334054845697622618461262852 i": +Test "Real part of: catan (0.75 + 1.25 i)": float: 4 ifloat: 4 -Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i) == 7.853981633974482679822974223765039144191e-1 + 3.725290298461914441624447420137706700965e-9 i": +Test "Imaginary part of: catan (0x0.fffffffffffff8p0 + 0x1p-27 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x0.ffffffffffffffffp0 + 0x1p-33 i) == 7.853981633974483095919439232967553115548e-1 + 5.820766091346740722958646680334721192083e-11 i": +Test "Imaginary part of: catan (0x0.ffffffffffffffffp0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i) == 7.853981373204155542484315721351697277336e-1 + 6.103515973639646453881721999956617260502e-5 i": +Test "Imaginary part of: catan (0x0.ffffffp0 + 0x1p-13 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1.0000000000001p0 + 0x1p-27 i) == 7.853981633974484345157511161499711112683e-1 + 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (0x1.0000000000001p0 + 0x1p-27 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.0000000000001p0 - 0x1p-27 i) == 7.853981633974484345157511161499711112683e-1 - 3.725290298461913200853528590596263270474e-9 i": +Test "Imaginary part of: catan (0x1.0000000000001p0 - 0x1p-27 i)": double: 1 idouble: 1 -Test "Real part of: catan (0x1.000002p0 + 0x1p-126 i) == 7.853982230020895322927482174768220815493e-1 + 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (0x1.000002p0 + 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1.000002p0 + 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 + 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1.000002p0 - 0x1p-126 i) == 7.853982230020895322927482174768220815493e-1 - 5.877471053462247139383742414506671233336e-39 i": +Test "Real part of: catan (0x1.000002p0 - 0x1p-126 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1.000002p0 - 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Real part of: catan (0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i) == 7.853982267273793866654490522673596014524e-1 - 6.103514882246036852433556327261700380577e-5 i": +Test "Imaginary part of: catan (0x1.000002p0 - 0x1p-13 i)": double: 1 idouble: 1 -Test "Imaginary part of: catan (0x1.3p-73 + 1.0 i) == 7.853981633974483096156922786831527361009e-1 + 2.556052055225464683726753902092495938633e1 i": +Test "Imaginary part of: catan (0x1.3p-73 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.3p-73 - 1.0 i) == 7.853981633974483096156922786831527361009e-1 - 2.556052055225464683726753902092495938633e1 i": +Test "Imaginary part of: catan (0x1.3p-73 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i) == 1.570796326794896619231321691639751442099 + 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i) == 1.570796326794896619231321691639751442099 - 2.871063043235098558826106732041811695767e-309 i": +Test "Imaginary part of: catan (0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i) == 1.570796326794896619231321691639751442097 + 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i) == 1.570796326794896619231321691639751442097 - 1.516766904286822590927401983512575068153e-39 i": +Test "Imaginary part of: catan (0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-1020 + 1.0 i) == 7.853981633974483096156608458198757210493e-1 + 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (0x1p-1020 + 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-1020 - 1.0 i) == 7.853981633974483096156608458198757210493e-1 - 3.538516356758520804574969980043991380025e2 i": +Test "Imaginary part of: catan (0x1p-1020 - 1.0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-1022 + 0x0.ffffffffffffffffp0 i) == 2.052268400649188124723641491045245971623e-289 + 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (0x1p-1022 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-1022 - 0x0.ffffffffffffffffp0 i) == 2.052268400649188124723641491045245971623e-289 - 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (0x1p-1022 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1p-13 + 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 + 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 + 1.0 i) == 7.854286809755354140031716771044626356262e-1 + 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 - 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Real part of: catan (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-13 - 0x1.000002p0 i) == 7.859169620684960844300240092596908675974e-1 - 4.852030056234795712498957387213592193975 i": +Test "Imaginary part of: catan (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-13 - 1.0 i) == 7.854286809755354140031716771044626356262e-1 - 4.852030264850939738801379894163661227127 i": +Test "Real part of: catan (0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-16382 + 0x0.ffffffffffffffffp0 i) == 3.100992811520163369065387859792822623745e-4913 + 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (0x1p-16382 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-16382 - 0x0.ffffffffffffffffp0 i) == 3.100992811520163369065387859792822623745e-4913 - 2.252728336819822255604649142023466965703e1 i": +Test "Imaginary part of: catan (0x1p-16382 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1p-27 + 1.0 i) == 7.853981652600934588466178684534110069553e-1 + 9.704060527839234335310696652368086117807 i": +Test "Real part of: catan (0x1p-27 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-27 - 1.0 i) == 7.853981652600934588466178684534110069553e-1 - 9.704060527839234335310696652368086117807 i": +Test "Real part of: catan (0x1p-27 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-33 + 0x0.ffffffffffffffffp0 i) == 7.853981631937214964185249205444919953948e-1 + 1.178350206951907026002603046195591193050e1 i": +Test "Imaginary part of: catan (0x1p-33 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1p-33 + 1.0 i) == 7.853981634265521400723945494331241018449e-1 + 1.178350206951907026009379309773625595762e1 i": +Test "Real part of: catan (0x1p-33 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-33 - 0x0.ffffffffffffffffp0 i) == 7.853981631937214964185249205444919953948e-1 - 1.178350206951907026002603046195591193050e1 i": +Test "Imaginary part of: catan (0x1p-33 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (0x1p-33 - 1.0 i) == 7.853981634265521400723945494331241018449e-1 - 1.178350206951907026009379309773625595762e1 i": +Test "Real part of: catan (0x1p-33 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-54 + 1.0 i) == 7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Real part of: catan (0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-54 + 1.0 i) == 7.853981633974483234934486536343324763447e-1 + 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-54 - 1.0 i) == 7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Real part of: catan (0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-54 - 1.0 i) == 7.853981633974483234934486536343324763447e-1 - 1.906154746539849600897388334009985581467e1 i": +Test "Imaginary part of: catan (0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-57 + 1.0 i) == 7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Real part of: catan (0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-57 + 1.0 i) == 7.853981633974483113503843217966828154612e-1 + 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catan (0x1p-57 - 1.0 i) == 7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Real part of: catan (0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-57 - 1.0 i) == 7.853981633974483113503843217966828154612e-1 - 2.010126823623841397309973152228712047720e1 i": +Test "Imaginary part of: catan (0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (0x1p-64 + 1.0 i) == 7.853981633974483096292133729759445264744e-1 + 2.252728336819822255606004394739073846245e1 i": +Test "Imaginary part of: catan (0x1p-64 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catan (0x1p-64 - 1.0 i) == 7.853981633974483096292133729759445264744e-1 - 2.252728336819822255606004394739073846245e1 i": +Test "Imaginary part of: catan (0x1p-64 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (1.0 + 0x1p-13 i) == 7.853981671227386080775748393881580082970e-1 + 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 + 0x1p-27 i) == 7.853981633974483234934486536343324763447e-1 + 3.725290298461914028034141143623846306386e-9 i": +Test "Real part of: catan (1.0 + 0x1p-27 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 + 0x1p-33 i) == 7.853981633974483096190489776088929224056e-1 + 5.820766091346740722643102318246316469910e-11 i": +Test "Real part of: catan (1.0 + 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 + 0x1p-54 i) == 7.853981633974483096156608458198764914213e-1 + 2.775557561562891351059079170227049355775e-17 i": +Test "Real part of: catan (1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 + 0x1p-57 i) == 7.853981633974483096156608458198757330864e-1 + 3.469446951953614188823848962783813448721e-18 i": +Test "Real part of: catan (1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (1.0 + 0x1p-64 i) == 7.853981633974483096156608458198757210500e-1 + 2.710505431213761085018632002174854278563e-20 i": +Test "Imaginary part of: catan (1.0 + 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (1.0 - 0x1p-13 i) == 7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Real part of: catan (1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (1.0 - 0x1p-13 i) == 7.853981671227386080775748393881580082970e-1 - 6.103515609841754902688560615027452023669e-5 i": +Test "Imaginary part of: catan (1.0 - 0x1p-13 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catan (1.0 - 0x1p-27 i) == 7.853981633974483234934486536343324763447e-1 - 3.725290298461914028034141143623846306386e-9 i": +Test "Real part of: catan (1.0 - 0x1p-27 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 - 0x1p-33 i) == 7.853981633974483096190489776088929224056e-1 - 5.820766091346740722643102318246316469910e-11 i": +Test "Real part of: catan (1.0 - 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 - 0x1p-54 i) == 7.853981633974483096156608458198764914213e-1 - 2.775557561562891351059079170227049355775e-17 i": +Test "Real part of: catan (1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catan (1.0 - 0x1p-57 i) == 7.853981633974483096156608458198757330864e-1 - 3.469446951953614188823848962783813448721e-18 i": +Test "Real part of: catan (1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catan (1.0 - 0x1p-64 i) == 7.853981633974483096156608458198757210500e-1 - 2.710505431213761085018632002174854278563e-20 i": +Test "Imaginary part of: catan (1.0 - 0x1p-64 i)": ildouble: 1 ldouble: 1 # catanh -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-1022 i) == -2.252728336819822255604649142023466965703e1 + 2.052268400649188124723641491045245971623e-289 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-16382 i) == -2.252728336819822255604649142023466965703e1 + 3.100992811520163369065387859792822623745e-4913 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-33 i) == -1.178350206951907026002603046195591193050e1 + 7.853981631937214964185249205444919953948e-1 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-1022 i) == -2.252728336819822255604649142023466965703e1 - 2.052268400649188124723641491045245971623e-289 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-16382 i) == -2.252728336819822255604649142023466965703e1 - 3.100992811520163369065387859792822623745e-4913 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-33 i) == -1.178350206951907026002603046195591193050e1 - 7.853981631937214964185249205444919953948e-1 i": +Test "Real part of: catanh (-0x0.ffffffffffffffffp0 - 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.000002p0 + 0x1p-13 i) == -4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Real part of: catanh (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1.000002p0 + 0x1p-13 i) == -4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (-0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1.000002p0 - 0x1p-13 i) == -4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Real part of: catanh (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1.000002p0 - 0x1p-13 i) == -4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (-0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i) == -2.871063043235098558826106732041811695767e-309 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i) == -2.871063043235098558826106732041811695767e-309 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (-0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i) == -1.516766904286822590927401983512575068153e-39 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (-0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i) == -1.516766904286822590927401983512575068153e-39 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (-0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-126 + 0x1.000002p0 i) == -5.877471053462247139383742414506671233336e-39 + 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (-0x1p-126 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-126 - 0x1.000002p0 i) == -5.877471053462247139383742414506671233336e-39 - 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (-0x1p-126 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Real part of: catanh (-0x1p-13 + 0x1.000002p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-13 + 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-13 + 1.0 i) == -6.103515609841754902688560615027452023669e-5 + 7.853981671227386080775748393881580082970e-1 i": +Test "Real part of: catanh (-0x1p-13 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-13 + 1.0 i) == -6.103515609841754902688560615027452023669e-5 + 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Real part of: catanh (-0x1p-13 - 0x1.000002p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-13 - 0x1.000002p0 i) == -6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-13 - 1.0 i) == -6.103515609841754902688560615027452023669e-5 - 7.853981671227386080775748393881580082970e-1 i": +Test "Real part of: catanh (-0x1p-13 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-0x1p-13 - 1.0 i) == -6.103515609841754902688560615027452023669e-5 - 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (-0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-27 + 0x1.0000000000001p0 i) == -3.725290298461913200853528590596263270474e-9 + 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (-0x1p-27 + 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-27 + 1.0 i) == -3.725290298461914028034141143623846306386e-9 + 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (-0x1p-27 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-27 - 0x1.0000000000001p0 i) == -3.725290298461913200853528590596263270474e-9 - 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (-0x1p-27 - 0x1.0000000000001p0 i)": double: 1 idouble: 1 -Test "Imaginary part of: catanh (-0x1p-27 - 1.0 i) == -3.725290298461914028034141143623846306386e-9 - 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (-0x1p-27 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-33 + 1.0 i) == -5.820766091346740722643102318246316469910e-11 + 7.853981633974483096190489776088929224056e-1 i": +Test "Imaginary part of: catanh (-0x1p-33 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-33 - 1.0 i) == -5.820766091346740722643102318246316469910e-11 - 7.853981633974483096190489776088929224056e-1 i": +Test "Imaginary part of: catanh (-0x1p-33 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-54 + 1.0 i) == -2.775557561562891351059079170227049355775e-17 + 7.853981633974483096156608458198764914213e-1 i": +Test "Imaginary part of: catanh (-0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-54 - 1.0 i) == -2.775557561562891351059079170227049355775e-17 - 7.853981633974483096156608458198764914213e-1 i": +Test "Imaginary part of: catanh (-0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-57 + 1.0 i) == -3.469446951953614188823848962783813448721e-18 + 7.853981633974483096156608458198757330864e-1 i": +Test "Imaginary part of: catanh (-0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-0x1p-57 - 1.0 i) == -3.469446951953614188823848962783813448721e-18 - 7.853981633974483096156608458198757330864e-1 i": +Test "Imaginary part of: catanh (-0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-0x1p-64 + 1.0 i) == -2.710505431213761085018632002174854278563e-20 + 7.853981633974483096156608458198757210500e-1 i": +Test "Real part of: catanh (-0x1p-64 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-0x1p-64 - 1.0 i) == -2.710505431213761085018632002174854278563e-20 - 7.853981633974483096156608458198757210500e-1 i": +Test "Real part of: catanh (-0x1p-64 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 + 0x1.3p-73 i) == -2.556052055225464683726753902092495938633e1 + 7.853981633974483096156922786831527361009e-1 i": +Test "Real part of: catanh (-1.0 + 0x1.3p-73 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 + 0x1p-1020 i) == -3.538516356758520804574969980043991380025e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-1020 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-13 i) == -4.852030264850939738801379894163661227127 + 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-27 i) == -9.704060527839234335310696652368086117807 + 7.853981652600934588466178684534110069553e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-27 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-33 i) == -1.178350206951907026009379309773625595762e1 + 7.853981634265521400723945494331241018449e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 + 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 + 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 + 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Imaginary part of: catanh (-1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 + 0x1p-64 i) == -2.252728336819822255606004394739073846245e1 + 7.853981633974483096292133729759445264744e-1 i": +Test "Real part of: catanh (-1.0 + 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 - 0x1.3p-73 i) == -2.556052055225464683726753902092495938633e1 - 7.853981633974483096156922786831527361009e-1 i": +Test "Real part of: catanh (-1.0 - 0x1.3p-73 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-1.0 - 0x1p-1020 i) == -3.538516356758520804574969980043991380025e2 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-1020 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-13 i) == -4.852030264850939738801379894163661227127 - 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-27 i) == -9.704060527839234335310696652368086117807 - 7.853981652600934588466178684534110069553e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-27 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-33 i) == -1.178350206951907026009379309773625595762e1 - 7.853981634265521400723945494331241018449e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-54 i) == -1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (-1.0 - 0x1p-57 i) == -2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Imaginary part of: catanh (-1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (-1.0 - 0x1p-64 i) == -2.252728336819822255606004394739073846245e1 - 7.853981633974483096292133729759445264744e-1 i": +Test "Real part of: catanh (-1.0 - 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Real part of: catanh (-2 - 3 i)": double: 4 idouble: 4 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (-2 - 3 i) == -0.14694666622552975204743278515471595 - 1.3389725222944935611241935759091443 i": +Test "Imaginary part of: catanh (-2 - 3 i)": float: 4 ifloat: 4 -Test "Real part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Real part of: catanh (0.75 + 1.25 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0.75 + 1.25 i) == 0.261492138795671927078652057366532140 + 0.996825126463918666098902241310446708 i": +Test "Imaginary part of: catanh (0.75 + 1.25 i)": float: 6 ifloat: 6 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-1022 i) == 2.252728336819822255604649142023466965703e1 + 2.052268400649188124723641491045245971623e-289 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-16382 i) == 2.252728336819822255604649142023466965703e1 + 3.100992811520163369065387859792822623745e-4913 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-33 i) == 1.178350206951907026002603046195591193050e1 + 7.853981631937214964185249205444919953948e-1 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 + 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-1022 i) == 2.252728336819822255604649142023466965703e1 - 2.052268400649188124723641491045245971623e-289 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-16382 i) == 2.252728336819822255604649142023466965703e1 - 3.100992811520163369065387859792822623745e-4913 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-33 i) == 1.178350206951907026002603046195591193050e1 - 7.853981631937214964185249205444919953948e-1 i": +Test "Real part of: catanh (0x0.ffffffffffffffffp0 - 0x1p-33 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1.000002p0 + 0x1p-13 i) == 4.852030056234795712498957387213592193975 + 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (0x1.000002p0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1.000002p0 - 0x1p-13 i) == 4.852030056234795712498957387213592193975 - 7.859169620684960844300240092596908675974e-1 i": +Test "Imaginary part of: catanh (0x1.000002p0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i) == 2.871063043235098558826106732041811695767e-309 + 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp1023 + 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i) == 2.871063043235098558826106732041811695767e-309 - 1.570796326794896619231321691639751442099 i": +Test "Real part of: catanh (0x1.fp1023 - 0x1.fp1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i) == 1.516766904286822590927401983512575068153e-39 + 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (0x1.fp127 + 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i) == 1.516766904286822590927401983512575068153e-39 - 1.570796326794896619231321691639751442097 i": +Test "Real part of: catanh (0x1.fp127 - 0x1.fp127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-126 + 0x1.000002p0 i) == 5.877471053462247139383742414506671233336e-39 + 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (0x1p-126 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-126 - 0x1.000002p0 i) == 5.877471053462247139383742414506671233336e-39 - 7.853982230020895322927482174768220815493e-1 i": +Test "Imaginary part of: catanh (0x1p-126 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i) == 6.103515973639646453881721999956617260502e-5 + 7.853981373204155542484315721351697277336e-1 i": +Test "Real part of: catanh (0x1p-13 + 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 + 0x1.000002p0 i) == 6.103514882246036852433556327261700380577e-5 + 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (0x1p-13 + 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 + 1.0 i) == 6.103515609841754902688560615027452023669e-5 + 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (0x1p-13 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i) == 6.103515973639646453881721999956617260502e-5 - 7.853981373204155542484315721351697277336e-1 i": +Test "Real part of: catanh (0x1p-13 - 0x0.ffffffp0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 - 0x1.000002p0 i) == 6.103514882246036852433556327261700380577e-5 - 7.853982267273793866654490522673596014524e-1 i": +Test "Imaginary part of: catanh (0x1p-13 - 0x1.000002p0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-13 - 1.0 i) == 6.103515609841754902688560615027452023669e-5 - 7.853981671227386080775748393881580082970e-1 i": +Test "Imaginary part of: catanh (0x1p-13 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i) == 3.725290298461914441624447420137706700965e-9 + 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (0x1p-27 + 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1p-27 + 0x1.0000000000001p0 i) == 3.725290298461913200853528590596263270474e-9 + 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (0x1p-27 + 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-27 + 1.0 i) == 3.725290298461914028034141143623846306386e-9 + 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (0x1p-27 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i) == 3.725290298461914441624447420137706700965e-9 - 7.853981633974482679822974223765039144191e-1 i": +Test "Real part of: catanh (0x1p-27 - 0x0.fffffffffffff8p0 i)": double: 1 idouble: 1 -Test "Real part of: catanh (0x1p-27 - 0x1.0000000000001p0 i) == 3.725290298461913200853528590596263270474e-9 - 7.853981633974484345157511161499711112683e-1 i": +Test "Real part of: catanh (0x1p-27 - 0x1.0000000000001p0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-27 - 1.0 i) == 3.725290298461914028034141143623846306386e-9 - 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (0x1p-27 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-33 + 0x0.ffffffffffffffffp0 i) == 5.820766091346740722958646680334721192083e-11 + 7.853981633974483095919439232967553115548e-1 i": +Test "Real part of: catanh (0x1p-33 + 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-33 + 1.0 i) == 5.820766091346740722643102318246316469910e-11 + 7.853981633974483096190489776088929224056e-1 i": +Test "Imaginary part of: catanh (0x1p-33 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-33 - 0x0.ffffffffffffffffp0 i) == 5.820766091346740722958646680334721192083e-11 - 7.853981633974483095919439232967553115548e-1 i": +Test "Real part of: catanh (0x1p-33 - 0x0.ffffffffffffffffp0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (0x1p-33 - 1.0 i) == 5.820766091346740722643102318246316469910e-11 - 7.853981633974483096190489776088929224056e-1 i": +Test "Imaginary part of: catanh (0x1p-33 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-54 + 1.0 i) == 2.775557561562891351059079170227049355775e-17 + 7.853981633974483096156608458198764914213e-1 i": +Test "Imaginary part of: catanh (0x1p-54 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-54 - 1.0 i) == 2.775557561562891351059079170227049355775e-17 - 7.853981633974483096156608458198764914213e-1 i": +Test "Imaginary part of: catanh (0x1p-54 - 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-57 + 1.0 i) == 3.469446951953614188823848962783813448721e-18 + 7.853981633974483096156608458198757330864e-1 i": +Test "Imaginary part of: catanh (0x1p-57 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (0x1p-57 - 1.0 i) == 3.469446951953614188823848962783813448721e-18 - 7.853981633974483096156608458198757330864e-1 i": +Test "Imaginary part of: catanh (0x1p-57 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (0x1p-64 + 1.0 i) == 2.710505431213761085018632002174854278563e-20 + 7.853981633974483096156608458198757210500e-1 i": +Test "Real part of: catanh (0x1p-64 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (0x1p-64 - 1.0 i) == 2.710505431213761085018632002174854278563e-20 - 7.853981633974483096156608458198757210500e-1 i": +Test "Real part of: catanh (0x1p-64 - 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 + 0x1.3p-73 i) == 2.556052055225464683726753902092495938633e1 + 7.853981633974483096156922786831527361009e-1 i": +Test "Real part of: catanh (1.0 + 0x1.3p-73 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 + 0x1p-1020 i) == 3.538516356758520804574969980043991380025e2 + 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-1020 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-13 i) == 4.852030264850939738801379894163661227127 + 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-27 i) == 9.704060527839234335310696652368086117807 + 7.853981652600934588466178684534110069553e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-27 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-33 i) == 1.178350206951907026009379309773625595762e1 + 7.853981634265521400723945494331241018449e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 + 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 + 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 + 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 + 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 + 7.853981633974483113503843217966828154612e-1 i": +Test "Imaginary part of: catanh (1.0 + 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 + 0x1p-64 i) == 2.252728336819822255606004394739073846245e1 + 7.853981633974483096292133729759445264744e-1 i": +Test "Real part of: catanh (1.0 + 0x1p-64 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 - 0x1.3p-73 i) == 2.556052055225464683726753902092495938633e1 - 7.853981633974483096156922786831527361009e-1 i": +Test "Real part of: catanh (1.0 - 0x1.3p-73 i)": ildouble: 1 ldouble: 1 -Test "Real part of: catanh (1.0 - 0x1p-1020 i) == 3.538516356758520804574969980043991380025e2 - 7.853981633974483096156608458198757210493e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-1020 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-13 i) == 4.852030264850939738801379894163661227127 - 7.854286809755354140031716771044626356262e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-13 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-27 i) == 9.704060527839234335310696652368086117807 - 7.853981652600934588466178684534110069553e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-27 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-33 i) == 1.178350206951907026009379309773625595762e1 - 7.853981634265521400723945494331241018449e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-33 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-54 i) == 1.906154746539849600897388334009985581467e1 - 7.853981633974483234934486536343324763447e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-54 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Imaginary part of: catanh (1.0 - 0x1p-57 i) == 2.010126823623841397309973152228712047720e1 - 7.853981633974483113503843217966828154612e-1 i": +Test "Imaginary part of: catanh (1.0 - 0x1p-57 i)": float: 1 ifloat: 1 -Test "Real part of: catanh (1.0 - 0x1p-64 i) == 2.252728336819822255606004394739073846245e1 - 7.853981633974483096292133729759445264744e-1 i": +Test "Real part of: catanh (1.0 - 0x1p-64 i)": ildouble: 1 ldouble: 1 # cbrt -Test "cbrt (-0.001) == -0.1": +Test "cbrt (-0.001)": ildouble: 1 ldouble: 1 -Test "cbrt (-27.0) == -3.0": +Test "cbrt (-27.0)": double: 1 idouble: 1 -Test "cbrt (0.75) == 0.908560296416069829445605878163630251": +Test "cbrt (0.75)": double: 1 idouble: 1 -Test "cbrt (0.9921875) == 0.997389022060725270579075195353955217": +Test "cbrt (0.9921875)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # ccos -Test "Imaginary part of: ccos (-0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (-0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Real part of: ccos (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (-2 - 3 i) == -4.18962569096880723013255501961597373 - 9.10922789375533659797919726277886212 i": +Test "Imaginary part of: ccos (-2 - 3 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Real part of: ccos (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 1.25 i) == 1.38173873063425888530729933139078645 - 1.09193013555397466170919531722024128 i": +Test "Imaginary part of: ccos (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccos (0.75 + 710.5 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 + 89.5 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0.75 - 710.5 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccos (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccos (0.75 - 89.5 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccos (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccos (0x1p-1074 + 1440 i) == inf - 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccos (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # ccosh -Test "Real part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Real part of: ccosh (-2 - 3 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-2 - 3 i) == -3.72454550491532256547397070325597253 + 0.511822569987384608834463849801875634 i": +Test "Imaginary part of: ccosh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ccosh (-710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (-89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (-89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Real part of: ccosh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ccosh (0.75 + 1.25 i) == 0.408242591877968807788852146397499084 + 0.780365930845853240391326216300863152 i": +Test "Imaginary part of: ccosh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: ccosh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: ccosh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: ccosh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ccosh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: ccosh (89.5 - 0.75 i)": float: 1 ifloat: 1 # cexp -Test "Real part of: cexp (-10000 + 0x1p16383 i) == 1.045876464564882298442774542991176546722e-4343 + 4.421154026488516836023811173959413420548e-4344 i": +Test "Real part of: cexp (-10000 + 0x1p16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-2.0 - 3.0 i) == -0.13398091492954261346140525546115575 - 0.019098516261135196432576240858800925 i": +Test "Imaginary part of: cexp (-2.0 - 3.0 i)": float: 1 ifloat: 1 -Test "Real part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Real part of: cexp (-95 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (-95 + 0.75 i) == 4.039714446238306526889476684000081624047e-42 + 3.763383677300535390271646960780570275931e-42 i": +Test "Imaginary part of: cexp (-95 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Real part of: cexp (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: cexp (0.75 + 1.25 i) == 0.667537446429131586942201977015932112 + 2.00900045494094876258347228145863909 i": +Test "Imaginary part of: cexp (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (11356.5625 + 0.75 i) == 9.052188470850960144814815984311663764287e4931 + 8.432986734191301036267148978260970230200e4931 i": +Test "Imaginary part of: cexp (11356.5625 + 0.75 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (1440 + 0x1p-1074 i) == inf + 1.196295853897226111293303155636183216483e302 i": +Test "Imaginary part of: cexp (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Real part of: cexp (50 + 0x1p127 i)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "Imaginary part of: cexp (50 + 0x1p127 i) == 4.053997150228616856622417636046265337193e21 + 3.232070315463388524466674772633810238819e21 i": +Test "Imaginary part of: cexp (50 + 0x1p127 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cexp (500 + 0x1p1023 i) == -1.159886268932754433233243794561351783426e217 + 7.904017694554466595359379965081774849708e216 i": +Test "Real part of: cexp (500 + 0x1p1023 i)": double: 1 idouble: 1 -Test "Real part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Real part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (709.8125 + 0.75 i) == 1.355121963080879535248452862759108365762e308 + 1.262426823598609432507811340856186873507e308 i": +Test "Imaginary part of: cexp (709.8125 + 0.75 i)": double: 1 idouble: 1 -Test "Real part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Real part of: cexp (88.75 + 0.75 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cexp (88.75 + 0.75 i) == 2.558360358486542817001900410314204322891e38 + 2.383359453227311447654736314679677655100e38 i": +Test "Imaginary part of: cexp (88.75 + 0.75 i)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # clog -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 2.649094276923003995420209214900915462737e-10 + 3.141592653589793238462643383279502884197 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 2.649094282537168795982991778475646793277e-10 + 3.141592652530155111500161671113150737892 i": +Test "Real part of: clog (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i) == 5.354083939753840089583620652120903838944e-25 - 1.570796326795931422008642456283782656359 i": +Test "Imaginary part of: clog (-0x1.234566p-40 - 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + pi i": +Test "Real part of: clog (-0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - pi i": +Test "Real part of: clog (-0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + pi i": +Test "Real part of: clog (-0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - pi i": +Test "Real part of: clog (-0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Imaginary part of: clog (-0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 -Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (-0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (-0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (-2 - 3 i) == 1.2824746787307683680267437207826593 - 2.1587989303424641704769327722648368 i": +Test "Imaginary part of: clog (-2 - 3 i)": float: 3 ifloat: 3 -Test "Real part of: clog (0.75 + 1.25 i) == 0.376885901188190075998919126749298416 + 1.03037682652431246378774332703115153 i": +Test "Real part of: clog (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i) == -5.421010862427522170184200798202494495630e-20 + 3.548665303440282824232502561095699343814e-4516 i": +Test "Real part of: clog (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -5.960464655174753498633255797994360530379e-8 + 7.888609052210118054117285652827862296732e-31 i": +Test "Real part of: clog (0x0.ffffffp0 + 0x0.ffffffp-100 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i) == 8.298731898331237038231468223024422855654e-5 + 1.110938609507128729312743251313024793990e-3 i": +Test "Real part of: clog (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.234566p-30 + 1.0 i) == 5.614163921211322622623353961365728040115e-19 + 1.570796325735258575254858696548386439740 i": +Test "Real part of: clog (0x1.234566p-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fffffep+127 + 0x1.fffffep+127 i) == 89.06941264234832570836679262104313101776 + pi/4 i": +Test "Real part of: clog (0x1.fffffep+127 + 0x1.fffffep+127 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i) == 88.69109041335841930424871526389807508374 + +0 i": +Test "Real part of: clog (0x1.fp+127 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i) == 88.69109041335841930424871526389807508374 - 0 i": +Test "Real part of: clog (0x1.fp+127 - 0x1p-149 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i) == 11356.83823118610934184548269774874545400 + pi/4 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p+16383 i) == 11356.60974243783798653123798337822335902 + 0.4764674194737066993385333770295162295856 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i) == 11356.49165759582936919077408168801636572 + +0 i": +Test "Real part of: clog (0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i) == 11356.49165759582936919077408168801636572 - 0 i": +Test "Real part of: clog (0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 5.0844550531823026520677817684239496041087e-32 + 1.2627468605458094918919206628466016525397 i": +Test "Imaginary part of: clog (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i) == -744.0934983311012896593986823853525458290 + pi/4 i": +Test "Real part of: clog (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-147 + 0x1p-147 i) == -101.5460619520319878296245057936228672231 + pi/4 i": +Test "Real part of: clog (0x1p-147 + 0x1p-147 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 + pi/2 i": +Test "Real part of: clog (0x1p-149 + 0x1.fp+127 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-149 + 0x1p-149 i) == -102.9323563131518784484589700365392203592 + pi/4 i": +Test "Real part of: clog (0x1p-149 + 0x1p-149 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i) == 88.69109041335841930424871526389807508374 - pi/2 i": +Test "Real part of: clog (0x1p-149 - 0x1.fp+127 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 + pi/2 i": +Test "Real part of: clog (0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i) == 11356.49165759582936919077408168801636572 - pi/2 i": +Test "Real part of: clog (0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i) == 1.5366822245016167178749091974664853785194e-08 + 1.2522014929038946066987318471922169174157 i": +Test "Imaginary part of: clog (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 -Test "Real part of: clog (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 4.4469229730850767799109418892826021157328e-20 + 1.2046235979300843056806465045930070146351 i": +Test "Real part of: clog (0x2dd46725bp-35 + 0x7783a1284p-35 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog (1.0 + 0x1.234566p-10 i) == 6.172834701221959432440126967147726538097e-7 + 1.111110564353742042376451655136933182201e-3 i": +Test "Real part of: clog (1.0 + 0x1.234566p-10 i)": float: 1 ifloat: 1 # clog10 -Test "Imaginary part of: clog10 (-0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i) == 1.150487026509145544402795327729455391948e-10 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-1000 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Real part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 2 idouble: 2 -Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i) == 1.150487028947346337782682105935961875822e-10 + 1.364376353381646356131680448946397884147 i": +Test "Imaginary part of: clog10 (-0x1.0000000123456p0 + 0x1.2345678p-30 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i) == 308.2409272754311106024666378243768099991 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i) == 308.2409272754311106024666378243768099991 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+1023 - 0x1p-1074 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i) == 38.51805116050395969095658815123105801479 + 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i) == 38.51805116050395969095658815123105801479 - 1.364376353841841347485783625431355770210 i": +Test "Imaginary part of: clog10 (-0x1.fp+127 - 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (-0x1.fp+16383 + 0x1p-16445 i) == 4932.061660674182269085496060792589701158 + 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (-0x1.fp+16383 - 0x1p-16445 i) == 4932.061660674182269085496060792589701158 - 1.364376353841841347485783625431355770210 i": +Test "Real part of: clog10 (-0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 + 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (-0x1p-149 - 0x1.fp+127 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (-0x1p-16445 + 0x1.fp+16383 i) == 4932.061660674182269085496060792589701158 + 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (-0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (-0x1p-16445 - 0x1.fp+16383 i) == 4932.061660674182269085496060792589701158 - 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (-0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i) == 2.556638434669064077889576526006849923281e-13 + 1.364375882602207106407956770293808181427 i": +Test "Imaginary part of: clog10 (-1.0 + 0x1.234566p-20 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-2 - 3 i) == 0.556971676153418384603252578971164214 - 0.937554462986374708541507952140189646 i": +Test "Imaginary part of: clog10 (-2 - 3 i)": double: 1 float: 5 idouble: 1 ifloat: 5 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (-3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (-3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 0 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + 1 i) == inf + pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf + inf i) == inf + 3/4 pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf + inf i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (-inf - 0 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (-inf - 1 i) == inf - pi*log10(e) i": +Test "Imaginary part of: clog10 (-inf - 1 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (0 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0.75 + 1.25 i) == 0.163679467193165171449476605077428975 + 0.447486970040493067069984724340855636 i": +Test "Real part of: clog10 (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i) == -4.821637332766435821255375046554377090472e-17 + 4.053112396770095089737411317782466262176e-302 i": +Test "Real part of: clog10 (0x0.fffffffffffff8p0 + 0x0.fffffffffffff8p-1000 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i) == -2.354315103889861110220423157644627849164e-20 + 1.541165759405643564697852372112893034397e-4516 i": +Test "Real part of: clog10 (0x0.ffffffffffffffffp0 + 0x0.ffffffffffffffffp-15000 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i) == -2.588596909321764128428416045209904492216e-8 + 3.425979381266895667295625489912064603415e-31 i": +Test "Real part of: clog10 (0x0.ffffffp0 + 0x0.ffffffp-100 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i) == 3.604093470239754109961125085078190708674e-5 + 4.824745078422174667425851670822596859720e-4 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-10 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Real part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i) == 3.577293486783822178310971763308187385546e-5 + 3.897399639875661463735636919790792140598e-31 i": +Test "Imaginary part of: clog10 (0x1.000566p0 + 0x1.234p-100 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Real part of: clog10 (0x1.234566p-30 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i) == 2.438200411482400072282924063740535840474e-19 + 6.821881764607257184291586401763604544928e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-30 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i) == 2.217530356103816369479108963807448194409e-31 + 6.821881769209202348667823902864283966959e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-50 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i) == 2.114801746467415208319767917450504756866e-37 + 6.821881769209206733143018621078368211515e-1 i": +Test "Imaginary part of: clog10 (0x1.234566p-60 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i) == 38.68235441693561449174780668781319348761 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffep+127 + 0x1.fffffep+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i) == 38.53183941910362389414093724045094697423 + 1.276276851248440096917018665609900318458e-39 i": +Test "Real part of: clog10 (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 308.4052305577487344482591243175787477115 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 308.3031705664207720674749211936626341569 + 0.2013595981366865903254995612594728746470 i": +Test "Real part of: clog10 (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i) == 4932.212175672014259683102930239951947672 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i) == 4932.112944269463028900262609694408579449 + 0.2069271710841128115912940666587802677383 i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1p+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 + 0x1p-16445 i) == 4932.061660674182269085496060792589701158 + +0 i": +Test "Real part of: clog10 (0x1.fp+16383 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1.fp+16383 - 0x1p-16445 i) == 4932.061660674182269085496060792589701158 - 0 i": +Test "Real part of: clog10 (0x1.fp+16383 - 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i) == 1.3918041236396763648388478552321724382899e-29 + 0.6263795733790237053262025311642907438291 i": +Test "Real part of: clog10 (0x10673dd0f2481p-51 + 0x7ef1d17cefbd2p-51 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x11682p-23 + 0x7ffed1p-23 i) == 5.0916490233953865181284669870035717560498e-13 + 0.6784968969384861816694467029319146542069 i": +Test "Imaginary part of: clog10 (0x11682p-23 + 0x7ffed1p-23 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Real part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i) == 2.2081507730821788480616336165447731164865e-32 + 0.5484039935757001196548030312819898864760 i": +Test "Imaginary part of: clog10 (0x1367a310575591p-54 + 0x3cfcc0a0541f60p-54 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i) == -1.3155760824064879362415202279780039150764e-26 + 0.3473590599762514228227328130640352044313 i": +Test "Imaginary part of: clog10 (0x164c74eea876p-45 + 0x16f393482f77p-45 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Real part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i) == -6.2126412844802358329771948751248003038444e-07 + 0.4977135139537443711784513409096950995985 i": +Test "Imaginary part of: clog10 (0x1a6p-10 + 0x3a5p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i) == -322.8546703496198318667349645920187712089 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1073 + 0x1p-1073 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i) == -323.1557003452838130619487034867432642357 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-1074 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i) == 308.2409272754311106024666378243768099991 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-1074 - 0x1.fp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i) == -44.10089436477324509881274807713822842154 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-147 + 0x1p-147 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (0x1p-149 + 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 + 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Real part of: clog10 (0x1p-149 + 0x1p-149 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i) == -44.70295435610120748924022586658721447508 + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (0x1p-149 + 0x1p-149 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (0x1p-149 - 0x1.fp+127 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i) == 38.51805116050395969095658815123105801479 - 0.6821881769209206737428918127156778851051 i": +Test "Imaginary part of: clog10 (0x1p-149 - 0x1.fp+127 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1p-16440 + 0x1p-16441 i) == -4948.884673709346821106688037612752099609 + 0.2013595981366865710389502301937289472543 i": +Test "Real part of: clog10 (0x1p-16440 + 0x1p-16441 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-16440 + 0x1p-16441 i) == -4948.884673709346821106688037612752099609 + 0.2013595981366865710389502301937289472543 i": +Test "Imaginary part of: clog10 (0x1p-16440 + 0x1p-16441 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1p-16445 + 0x1.fp+16383 i) == 4932.061660674182269085496060792589701158 + 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (0x1p-16445 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x1p-16445 - 0x1.fp+16383 i) == 4932.061660674182269085496060792589701158 - 0.6821881769209206737428918127156778851051 i": +Test "Real part of: clog10 (0x1p-16445 - 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i) == 7.730698388614835910296270976605350994446e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-509 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i) == 1.932674597153708977574067744151337748612e-308 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-510 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i) == 4.831686492884272443935169360378344371529e-309 + 6.821881769209206737428918127156778851051e-1 i": +Test "Imaginary part of: clog10 (0x1p-511 + 1.0 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i) == 4.084085680564517578238994467153626207224e-38 + 6.821881769209206735545466044044889962925e-1 i": +Test "Imaginary part of: clog10 (0x1p-61 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i) == 1.021021420141129394559748616788406551878e-38 + 6.821881769209206736487192085600834406988e-1 i": +Test "Imaginary part of: clog10 (0x1p-62 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i) == 2.552553550352823486399371541971016379740e-39 + 6.821881769209206736958055106378806629019e-1 i": +Test "Imaginary part of: clog10 (0x1p-63 + 1.0 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Real part of: clog10 (0x1p-8190 + 1.0 i) == 2.920285685286322365786846845062520925172e-4932 + 6.821881769209206737428918127156778851051e-1 i": +Test "Real part of: clog10 (0x1p-8190 + 1.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Real part of: clog10 (0x2818p-15 + 0x798fp-15 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i) == 6.6737261053986614395049481326819059203910e-09 + 0.5438241985991753781478398141908629586460 i": +Test "Imaginary part of: clog10 (0x2818p-15 + 0x798fp-15 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Real part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i) == 1.9312741086596516918394613098872836703188e-20 + 0.5231613813514771042838490538484014771862 i": +Test "Imaginary part of: clog10 (0x2dd46725bp-35 + 0x7783a1284p-35 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Real part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i) == -1.9440841725722970687903291200493082253766e-13 + 0.5193774116724956222518530053006822210323 i": +Test "Imaginary part of: clog10 (0x2ede88p-23 + 0x771c3fp-23 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Real part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i) == -6.4375803621988389731799033530075237868110e-21 + 0.4378257977686804492768642780897650927167 i": +Test "Imaginary part of: clog10 (0x4447d7175p-35 + 0x6c445e00ap-35 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i) == -7.0781945783414996953799915941870192015212e-09 + 0.4005747524909781155537088181659175147564 i": +Test "Real part of: clog10 (0x4d4ep-15 + 0x6605p-15 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i) == 3.6079845358966994996207055940336690133424e-30 + 0.5243112258263349992771652393178033846555 i": +Test "Imaginary part of: clog10 (0x5b06b680ea2ccp-52 + 0xef452b965da9fp-52 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x659b70ab7971bp-53 + 0x1f5d111e08abecp-53 i) == -1.0893543813872082317104059174982092534059e-30 + 0.5954257879188711495921161433751775633232 i": +Test "Imaginary part of: clog10 (0x659b70ab7971bp-53 + 0x1f5d111e08abecp-53 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i) == 1.6200701438094619117335617123525612051457e-14 + 0.5049027913635038013499728086604870749732 i": +Test "Imaginary part of: clog10 (0x659feap-24 + 0xeaf6f9p-24 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i) == 1.0529283395205396881397407610630442563938e-37 + 0.4947949395762683446121140513971996916447 i": +Test "Imaginary part of: clog10 (0x6b10b4f3520217b6p-64 + 0xe8893cbb449253a1p-64 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x81b7efa81fc35ad1p-65 + 0x1ef4b835f1c79d812p-65 i) == -4.3074341162203896332989394770760901408798e-39 + 0.5709443672155660428417571212549720987784 i": +Test "Imaginary part of: clog10 (0x81b7efa81fc35ad1p-65 + 0x1ef4b835f1c79d812p-65 i)": ildouble: 1 ldouble: 1 -Test "Real part of: clog10 (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i) == -4.2289432987513243393180377141513840878196e-30 + 0.4252020027092323591068799049905597805296 i": +Test "Real part of: clog10 (0x8ecbf810c4ae6p-52 + 0xd479468b09a37p-52 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i) == -1.7182001068739620267773842120965071561416e-11 + 0.3990121149225253562859800593935899629087 i": +Test "Imaginary part of: clog10 (0x9b57bp-20 + 0xcb7b4p-20 i)": double: 1 idouble: 1 -Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Real part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i) == 2.6921240173351112953324592659528481616879e-06 + 0.5785726025799636431142862788413361783862 i": +Test "Imaginary part of: clog10 (0xf2p-10 + 0x3e3p-10 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i) == 2.3329549194675052736016290082882121135546e-26 + 0.4561756099441139182878993697611751382976 i": +Test "Imaginary part of: clog10 (0xfe961079616p-45 + 0x1bc37e09e6d1p-45 i)": double: 1 idouble: 1 -Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i) == 2.680828048441605163181684680300513080769e-7 + 4.825491868832381486767558728169977751564e-4 i": +Test "Imaginary part of: clog10 (1.0 + 0x1.234566p-10 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: clog10 (3 + inf i) == inf + pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (3 - inf i) == inf - pi/2*log10(e) i": +Test "Imaginary part of: clog10 (3 - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf + inf i) == inf + pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf + inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: clog10 (inf - inf i) == inf - pi/4*log10(e) i": +Test "Imaginary part of: clog10 (inf - inf i)": double: 1 float: 1 idouble: 1 ifloat: 1 # cos -Test "cos (0.80190127184058835) == 0.69534156199418473": +Test "cos (0.80190127184058835)": double: 1 idouble: 1 -Test "cos (M_PI_6l * 2.0) == 0.5": +Test "cos (M_PI_6l * 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "cos (M_PI_6l * 4.0) == -0.5": +Test "cos (M_PI_6l * 4.0)": double: 2 float: 1 idouble: 2 @@ -5693,227 +5693,227 @@ ildouble: 1 ldouble: 1 # cos_downward -Test "cos_downward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_downward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_downward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_downward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_downward (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_downward (5)": float: 1 ifloat: 1 -Test "cos_downward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_downward (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_downward (8)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_downward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_downward (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cos_tonearest -Test "cos_tonearest (7) == 0.7539022543433046381411975217191820122183": +Test "cos_tonearest (7)": float: 1 ifloat: 1 -Test "cos_tonearest (8) == -0.1455000338086135258688413818311946826093": +Test "cos_tonearest (8)": ildouble: 1 ldouble: 1 -Test "cos_tonearest (9) == -0.9111302618846769883682947111811653112463": +Test "cos_tonearest (9)": ildouble: 1 ldouble: 1 # cos_towardzero -Test "cos_towardzero (1) == 0.5403023058681397174009366074429766037323": +Test "cos_towardzero (1)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (10) == -0.8390715290764524522588639478240648345199": +Test "cos_towardzero (10)": ildouble: 1 ldouble: 1 -Test "cos_towardzero (2) == -0.4161468365471423869975682295007621897660": +Test "cos_towardzero (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (3) == -0.9899924966004454572715727947312613023937": +Test "cos_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (5) == 0.2836621854632262644666391715135573083344": +Test "cos_towardzero (5)": float: 1 ifloat: 1 -Test "cos_towardzero (7) == 0.7539022543433046381411975217191820122183": +Test "cos_towardzero (7)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_towardzero (8) == -0.1455000338086135258688413818311946826093": +Test "cos_towardzero (8)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cos_upward -Test "cos_upward (1) == 0.5403023058681397174009366074429766037323": +Test "cos_upward (1)": float: 1 ifloat: 1 -Test "cos_upward (10) == -0.8390715290764524522588639478240648345199": +Test "cos_upward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (2) == -0.4161468365471423869975682295007621897660": +Test "cos_upward (2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (3) == -0.9899924966004454572715727947312613023937": +Test "cos_upward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (4) == -0.6536436208636119146391681830977503814241": +Test "cos_upward (4)": ildouble: 1 ldouble: 1 -Test "cos_upward (5) == 0.2836621854632262644666391715135573083344": +Test "cos_upward (5)": ildouble: 1 ldouble: 1 -Test "cos_upward (6) == 0.9601702866503660205456522979229244054519": +Test "cos_upward (6)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (7) == 0.7539022543433046381411975217191820122183": +Test "cos_upward (7)": float: 1 ifloat: 1 -Test "cos_upward (8) == -0.1455000338086135258688413818311946826093": +Test "cos_upward (8)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cos_upward (9) == -0.9111302618846769883682947111811653112463": +Test "cos_upward (9)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 # cosh_downward -Test "cosh_downward (22) == 1792456423.065795780980053377632656584997": +Test "cosh_downward (22)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "cosh_downward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_downward (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_downward (24) == 13244561064.92173614708845674912733665919": +Test "cosh_downward (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_tonearest -Test "cosh_tonearest (22) == 1792456423.065795780980053377632656584997": +Test "cosh_tonearest (22)": ildouble: 1 ldouble: 1 # cosh_towardzero -Test "cosh_towardzero (22) == 1792456423.065795780980053377632656584997": +Test "cosh_towardzero (22)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "cosh_towardzero (23) == 4872401723.124451300068625740569997090344": +Test "cosh_towardzero (23)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "cosh_towardzero (24) == 13244561064.92173614708845674912733665919": +Test "cosh_towardzero (24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # cosh_upward -Test "cosh_upward (23) == 4872401723.124451300068625740569997090344": +Test "cosh_upward (23)": ildouble: 1 ldouble: 1 # cpow -Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i) == 0.331825439177608832276067945276730566 + 0.131338600281188544930936345230903032 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.0 + 1.0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Real part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 5 ldouble: 5 -Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i) == 0.117506293914473555420279832210420483 + 0.346552747708338676483025352060418001 i": +Test "Imaginary part of: cpow (0.75 + 1.25 i, 0.75 + 1.25 i)": ildouble: 2 ldouble: 2 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i) == 0.75 + 1.25 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 0.0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i) == 0.0846958290317209430433805274189191353 + 0.513285749182902449043287190519090481 i": +Test "Real part of: cpow (0.75 + 1.25 i, 1.0 + 1.0 i)": double: 2 float: 3 idouble: 2 ifloat: 3 ildouble: 3 ldouble: 3 -Test "Real part of: cpow (2 + 0 i, 10 + 0 i) == 1024.0 + 0.0 i": +Test "Real part of: cpow (2 + 0 i, 10 + 0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Real part of: cpow (2 + 3 i, 4 + 0 i)": double: 1 float: 5 idouble: 1 ifloat: 5 ildouble: 1 ldouble: 1 -Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i) == -119.0 - 120.0 i": +Test "Imaginary part of: cpow (2 + 3 i, 4 + 0 i)": float: 2 ifloat: 2 ildouble: 4 ldouble: 4 -Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i) == 1.0 + 0.0 i": +Test "Imaginary part of: cpow (e + 0 i, 0 + 2 * M_PIl i)": double: 2 float: 2 idouble: 2 @@ -5922,284 +5922,284 @@ ildouble: 1 ldouble: 1 # csin -Test "Real part of: csin (-0.75 + 710.5 i) == -1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 + 89.5 i) == -2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (-0.75 - 710.5 i) == -1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (-0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (-0.75 - 89.5 i) == -2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (-0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csin (-2 - 3 i) == -9.15449914691142957346729954460983256 + 4.16890695996656435075481305885375484 i": +Test "Imaginary part of: csin (-2 - 3 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Real part of: csin (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csin (0.75 + 1.25 i) == 1.28722291002649188575873510790565441 + 1.17210635989270256101081285116138863 i": +Test "Imaginary part of: csin (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 + 710.5 i) == 1.255317763348154410745082950806112487736e308 + 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 + 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 + 89.5 i) == 2.522786001038096774676288412995370563339e38 + 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 + 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0.75 - 710.5 i) == 1.255317763348154410745082950806112487736e308 - 1.347490911916428129246890157395342279438e308 i": +Test "Real part of: csin (0.75 - 710.5 i)": double: 1 idouble: 1 -Test "Real part of: csin (0.75 - 89.5 i) == 2.522786001038096774676288412995370563339e38 - 2.708024460708609732016532185663087200560e38 i": +Test "Real part of: csin (0.75 - 89.5 i)": float: 1 ifloat: 1 -Test "Real part of: csin (0x1p-1074 + 1440 i) == 5.981479269486130556466515778180916082415e301 + inf i": +Test "Real part of: csin (0x1p-1074 + 1440 i)": double: 1 idouble: 1 # csinh -Test "Real part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Real part of: csinh (-2 - 3 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-2 - 3 i) == 3.59056458998577995201256544779481679 - 0.530921086248519805267040090660676560 i": +Test "Imaginary part of: csinh (-2 - 3 i)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: csinh (-710.5 + 0.75 i) == -1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-710.5 - 0.75 i) == -1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (-710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (-89.5 + 0.75 i) == -2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (-89.5 - 0.75 i) == -2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (-89.5 - 0.75 i)": float: 1 ifloat: 1 -Test "Real part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Real part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csinh (0.75 + 1.25 i) == 0.259294854551162779153349830618433028 + 1.22863452409509552219214606515777594 i": +Test "Imaginary part of: csinh (0.75 + 1.25 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (1440 + 0x1p-1074 i) == inf + 5.981479269486130556466515778180916082415e301 i": +Test "Imaginary part of: csinh (1440 + 0x1p-1074 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 + 0.75 i) == 1.347490911916428129246890157395342279438e308 + 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 + 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (710.5 - 0.75 i) == 1.347490911916428129246890157395342279438e308 - 1.255317763348154410745082950806112487736e308 i": +Test "Imaginary part of: csinh (710.5 - 0.75 i)": double: 1 idouble: 1 -Test "Imaginary part of: csinh (89.5 + 0.75 i) == 2.708024460708609732016532185663087200560e38 + 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 + 0.75 i)": float: 1 ifloat: 1 -Test "Imaginary part of: csinh (89.5 - 0.75 i) == 2.708024460708609732016532185663087200560e38 - 2.522786001038096774676288412995370563339e38 i": +Test "Imaginary part of: csinh (89.5 - 0.75 i)": float: 1 ifloat: 1 # csqrt -Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Real part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i) == 8.344545284118961664300307045791497724440e-2467 - 2.014551439675644900131815801350165472778e-2466 i": +Test "Imaginary part of: csqrt (-0x1.0000000000000002p-16382 - 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i) == 6.788430486774966350907249113759995429568e-155 - 1.638872094839911521020410942677082920935e-154 i": +Test "Real part of: csqrt (-0x1.0000000000001p-1022 - 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i) == 4.934094449071842328766868579214125217132e-20 - 1.191195773697904627170323731331667740087e-19 i": +Test "Real part of: csqrt (-0x1.000002p-126 - 0x1.000002p-126 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: csqrt (-2 + 3 i) == 0.89597747612983812471573375529004348 + 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 + 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (-2 - 3 i) == 0.89597747612983812471573375529004348 - 1.6741492280355400404480393008490519 i": +Test "Real part of: csqrt (-2 - 3 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Real part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i) == 2.014551439675644900131815801350165472778e-2466 + 8.344545284118961664300307045791497724440e-2467 i": +Test "Imaginary part of: csqrt (0x1.0000000000000002p-16382 + 0x1.0000000000000002p-16382 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i) == 1.638872094839911521020410942677082920935e-154 + 6.788430486774966350907249113759995429568e-155 i": +Test "Imaginary part of: csqrt (0x1.0000000000001p-1022 + 0x1.0000000000001p-1022 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i) == 1.191195773697904627170323731331667740087e-19 + 4.934094449071842328766868579214125217132e-20 i": +Test "Imaginary part of: csqrt (0x1.000002p-126 + 0x1.000002p-126 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i) == 1.844674352395372953599975585936590505260e+19 + 2.710505511993121390769065968615872097053e-20 i": +Test "Imaginary part of: csqrt (0x1.fffffep+127 + 1.0 i)": float: 1 ifloat: 1 -Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Real part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i) == 1.473094556905565378990473658199034571917e+154 + 6.101757441282702188537080005372547713595e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1.fffffffffffffp+1023 i)": double: 1 idouble: 1 -Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i) == 1.379778091031440685006200821918878702861e+154 + 3.257214233483129514781233066898042490248e+153 i": +Test "Imaginary part of: csqrt (0x1.fffffffffffffp+1023 + 0x1p+1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i) == 1.179514222452201722651836720466795901016e+2466 + 4.885707879516577666702435054303191575148e+2465 i": +Test "Imaginary part of: csqrt (0x1.fp+16383 + 0x1.fp+16383 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-1073 + 0x1p-1073 i) == 3.453664695497464982856905711457966660085e-162 + 1.430554756764195530630723976279903095110e-162 i": +Test "Imaginary part of: csqrt (0x1p-1073 + 0x1p-1073 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-1074 + 0x1p-1074 i) == 2.442109726130830256743814843868934877597e-162 + 1.011554969366634726113090867589031782487e-162 i": +Test "Imaginary part of: csqrt (0x1p-1074 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-147 + 0x1p-147 i) == 8.225610928685557596194006925540350401606e-23 + 3.407159605465907500737319471202779419102e-23 i": +Test "Imaginary part of: csqrt (0x1p-147 + 0x1p-147 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: csqrt (0x1p-149 + 0x1p-149 i) == 4.112805464342778798097003462770175200803e-23 + 1.703579802732953750368659735601389709551e-23 i": +Test "Imaginary part of: csqrt (0x1p-149 + 0x1p-149 i)": ildouble: 1 ldouble: 1 # ctan -Test "Real part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Real part of: ctan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (-2 - 3 i) == 0.376402564150424829275122113032269084e-2 - 1.00323862735360980144635859782192726 i": +Test "Imaginary part of: ctan (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Real part of: ctan (0.75 + 1.25 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0.75 + 1.25 i) == 0.160807785916206426725166058173438663 + 0.975363285031235646193581759755216379 i": +Test "Imaginary part of: ctan (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Real part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Real part of: ctan (0x1p1023 + 1 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan (0x1p1023 + 1 i) == -0.2254627924997545057926782581695274244229 + 0.8786063118883068695462540226219865087189 i": +Test "Imaginary part of: ctan (0x1p1023 + 1 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Real part of: ctan (0x1p127 + 1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan (0x1p127 + 1 i) == 0.2446359391192790896381501310437708987204 + 0.9101334047676183761532873794426475906201 i": +Test "Imaginary part of: ctan (0x1p127 + 1 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Real part of: ctan (0x3.243f6cp-1 + 0 i) == -2.287733242885645987394874673945769518150e7 + 0.0 i": +Test "Real part of: ctan (0x3.243f6cp-1 + 0 i)": float: 1 ifloat: 1 -Test "Real part of: ctan (1 + 45 i) == 1.490158918874345552942703234806348520895e-39 + 1.000000000000000000000000000000000000001 i": +Test "Real part of: ctan (1 + 45 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan (1 + 47 i) == 2.729321264492904590777293425576722354636e-41 + 1.0 i": +Test "Real part of: ctan (1 + 47 i)": ildouble: 2 ldouble: 2 # ctan_downward -Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_downward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_downward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 3 ldouble: 3 -Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_downward (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 4 ldouble: 4 # ctan_tonearest -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_tonearest (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # ctan_towardzero -Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_towardzero (0x1.921fb6p+0 + 0x1p-149 i)": float: 1 ifloat: 1 ildouble: 4 ldouble: 4 # ctan_upward -Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Real part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i) == -3.986797629811710706723242948653362815645e19 + 5.793882568875674066286163141055208625180e-4912 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d1846ap+0 + 0x1p-16445 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Real part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i) == 1.633123935319536975596773704152891653086e16 + 1.317719414943508315995636961402669067843e-291 i": +Test "Imaginary part of: ctan_upward (0x1.921fb54442d18p+0 + 0x1p-1074 i)": ildouble: 4 ldouble: 4 -Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Real part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i) == -2.287733242885645987394874673945769518150e7 + 7.334008549954377778731880988481078535821e-31 i": +Test "Imaginary part of: ctan_upward (0x1.921fb6p+0 + 0x1p-149 i)": double: 1 float: 2 idouble: 1 @@ -6208,521 +6208,533 @@ ildouble: 1 ldouble: 1 # ctanh -Test "Real part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Real part of: ctanh (-2 - 3 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh (-2 - 3 i) == -0.965385879022133124278480269394560686 + 0.988437503832249372031403430350121098e-2 i": +Test "Imaginary part of: ctanh (-2 - 3 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i) == 0.0 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh (0 + 0x3.243f6cp-1 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0 + pi/4 i) == 0.0 + 1.0 i": +Test "Imaginary part of: ctanh (0 + pi/4 i)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Real part of: ctanh (0.75 + 1.25 i)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "Imaginary part of: ctanh (0.75 + 1.25 i) == 1.37260757053378320258048606571226857 + 0.385795952609750664177596760720790220 i": +Test "Imaginary part of: ctanh (0.75 + 1.25 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Real part of: ctanh (1 + 0x1p1023 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (1 + 0x1p1023 i) == 0.8786063118883068695462540226219865087189 - 0.2254627924997545057926782581695274244229 i": +Test "Imaginary part of: ctanh (1 + 0x1p1023 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Real part of: ctanh (1 + 0x1p127 i)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "Imaginary part of: ctanh (1 + 0x1p127 i) == 0.9101334047676183761532873794426475906201 + 0.2446359391192790896381501310437708987204 i": +Test "Imaginary part of: ctanh (1 + 0x1p127 i)": float: 1 ifloat: 1 -Test "Imaginary part of: ctanh (45 + 1 i) == 1.000000000000000000000000000000000000001 + 1.490158918874345552942703234806348520895e-39 i": +Test "Imaginary part of: ctanh (45 + 1 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh (47 + 1 i) == 1.0 + 2.729321264492904590777293425576722354636e-41 i": +Test "Imaginary part of: ctanh (47 + 1 i)": ildouble: 2 ldouble: 2 # ctanh_downward -Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_downward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_downward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 3 ldouble: 3 -Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_downward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_tonearest -Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_tonearest (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_tonearest (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 -Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_tonearest (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 # ctanh_towardzero -Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_towardzero (0x1p-149 + 0x1.921fb6p+0 i)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # ctanh_upward -Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Real part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": ildouble: 4 ldouble: 4 -Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i) == 1.317719414943508315995636961402669067843e-291 + 1.633123935319536975596773704152891653086e16 i": +Test "Imaginary part of: ctanh_upward (0x1p-1074 + 0x1.921fb54442d18p+0 i)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Real part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i) == 7.334008549954377778731880988481078535821e-31 - 2.287733242885645987394874673945769518150e7 i": +Test "Imaginary part of: ctanh_upward (0x1p-149 + 0x1.921fb6p+0 i)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Real part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 1 ldouble: 1 -Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i) == 5.793882568875674066286163141055208625180e-4912 - 3.986797629811710706723242948653362815645e19 i": +Test "Imaginary part of: ctanh_upward (0x1p-16445 + 0x1.921fb54442d1846ap+0 i)": ildouble: 2 ldouble: 2 # erf -Test "erf (1.25) == 0.922900128256458230136523481197281140": +Test "erf (1.25)": double: 1 idouble: 1 # erfc -Test "erfc (0x1.f7303cp+1) == 2.705500297238986897105236321218861842255e-8": +Test "erfc (0x1.f7303cp+1)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "erfc (0x1.ffa002p+2) == 1.233585992097580296336099501489175967033e-29": +Test "erfc (0x1.ffa002p+2)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "erfc (1.25) == 0.0770998717435417698634765188027188596": +Test "erfc (1.25)": ildouble: 1 ldouble: 1 -Test "erfc (2.0) == 0.00467773498104726583793074363274707139": +Test "erfc (2.0)": double: 1 idouble: 1 -Test "erfc (4.125) == 0.542340079956506600531223408575531062e-8": +Test "erfc (4.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # exp10 -Test "exp10 (-1) == 0.1": +Test "exp10 (-1)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "exp10 (-305) == 1.0e-305": +Test "exp10 (-305)": double: 1 idouble: 1 -Test "exp10 (-36) == 1.0e-36": +Test "exp10 (-36)": double: 1 idouble: 1 -Test "exp10 (0.75) == 5.62341325190349080394951039776481231": +Test "exp10 (0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "exp10 (3) == 1000": +Test "exp10 (3)": double: 6 float: 2 idouble: 6 ifloat: 2 ildouble: 8 ldouble: 8 -Test "exp10 (36) == 1.0e36": +Test "exp10 (36)": double: 1 idouble: 1 # exp_downward -Test "exp_downward (1) == e": +Test "exp_downward (1)": ildouble: 1 ldouble: 1 -Test "exp_downward (2) == e^2": +Test "exp_downward (2)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "exp_downward (3) == e^3": +Test "exp_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_towardzero -Test "exp_towardzero (1) == e": +Test "exp_towardzero (1)": ildouble: 1 ldouble: 1 -Test "exp_towardzero (2) == e^2": +Test "exp_towardzero (2)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "exp_towardzero (3) == e^3": +Test "exp_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # exp_upward -Test "exp_upward (1) == e": +Test "exp_upward (1)": float: 1 ifloat: 1 # expm1 -Test "expm1 (-45.0) == -0.9999999999999999999713748141945060635553": +Test "expm1 (-45.0)": ildouble: 1 ldouble: 1 -Test "expm1 (0.75) == 1.11700001661267466854536981983709561": +Test "expm1 (0.75)": double: 1 idouble: 1 -Test "expm1 (1) == M_El - 1.0": +Test "expm1 (1)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "expm1 (11356.25) == 9.05128237311923300051376115753226014206e+4931": +Test "expm1 (11356.25)": ildouble: 1 ldouble: 1 -Test "expm1 (500.0) == 1.4035922178528374107397703328409120821806e+217": +Test "expm1 (500.0)": double: 1 idouble: 1 # gamma -Test "gamma (-0.5) == log(2*sqrt(pi))": +Test "gamma (-0.5)": +ildouble: 1 +ldouble: 1 +Test "gamma (0.7)": +double: 1 +float: 1 +idouble: 1 +ifloat: 1 +Test "gamma (1.2)": +double: 1 +float: 2 +idouble: 1 +ifloat: 2 ildouble: 1 ldouble: 1 # hypot -Test "hypot (-0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (-0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (-0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (-12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (-12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (-12.4, 0.7)": float: 1 ifloat: 1 -Test "hypot (0.7, -12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, -12.4)": float: 1 ifloat: 1 -Test "hypot (0.7, 12.4) == 12.419742348374220601176836866763271": +Test "hypot (0.7, 12.4)": float: 1 ifloat: 1 -Test "hypot (12.4, -0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, -0.7)": float: 1 ifloat: 1 -Test "hypot (12.4, 0.7) == 12.419742348374220601176836866763271": +Test "hypot (12.4, 0.7)": float: 1 ifloat: 1 # j0 -Test "j0 (-0x1.001000001p+593) == -3.927269966354206207832593635798954916263e-90": +Test "j0 (-0x1.001000001p+593)": ildouble: 2 ldouble: 2 -Test "j0 (-4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (-4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "j0 (0.75) == 0.864242275166648623555731103820923211": +Test "j0 (0.75)": float: 1 ifloat: 1 -Test "j0 (0x1.d7ce3ap+107) == 2.775523647291230802651040996274861694514e-17": +Test "j0 (0x1.d7ce3ap+107)": float: 2 ifloat: 2 -Test "j0 (0x1p16382) == -1.2193782500509000574176799046642541129387e-2466": +Test "j0 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "j0 (10.0) == -0.245935764451348335197760862485328754": +Test "j0 (10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "j0 (2.0) == 0.223890779141235668051827454649948626": +Test "j0 (2.0)": float: 2 ifloat: 2 -Test "j0 (4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "j0 (4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "j0 (8.0) == 0.171650807137553906090869407851972001": +Test "j0 (8.0)": double: 2 float: 1 idouble: 2 ifloat: 1 # j1 -Test "j1 (0x1.3ffp+74) == 1.818984347516051243459364437186082741567e-12": +Test "j1 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "j1 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "j1 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "j1 (0x1p16382) == 8.0839224448726336195866026476176740513439e-2467": +Test "j1 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "j1 (10.0) == 0.0434727461688614366697487680258592883": +Test "j1 (10.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "j1 (2.0) == 0.576724807756873387202448242269137087": +Test "j1 (2.0)": double: 1 idouble: 1 -Test "j1 (8.0) == 0.234636346853914624381276651590454612": +Test "j1 (8.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # jn -Test "jn (0, -4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, -4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (0, 0.75) == 0.864242275166648623555731103820923211": +Test "jn (0, 0.75)": float: 1 ifloat: 1 -Test "jn (0, 10.0) == -0.245935764451348335197760862485328754": +Test "jn (0, 10.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (0, 2.0) == 0.223890779141235668051827454649948626": +Test "jn (0, 2.0)": float: 2 ifloat: 2 -Test "jn (0, 4.0) == -3.9714980986384737228659076845169804197562E-1": +Test "jn (0, 4.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (0, 8.0) == 0.171650807137553906090869407851972001": +Test "jn (0, 8.0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "jn (1, 10.0) == 0.0434727461688614366697487680258592883": +Test "jn (1, 10.0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (1, 2.0) == 0.576724807756873387202448242269137087": +Test "jn (1, 2.0)": double: 1 idouble: 1 -Test "jn (1, 8.0) == 0.234636346853914624381276651590454612": +Test "jn (1, 8.0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "jn (10, -1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 0.125) == 0.250543369809369890173993791865771547e-18": +Test "jn (10, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (10, 0.75) == 0.149621713117596814698712483621682835e-10": +Test "jn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "jn (10, 1.0) == 0.263061512368745320699785368779050294e-9": +Test "jn (10, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (10, 10.0) == 0.207486106633358857697278723518753428": +Test "jn (10, 10.0)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 2 ldouble: 2 -Test "jn (10, 2.0) == 0.251538628271673670963516093751820639e-6": +Test "jn (10, 2.0)": double: 1 float: 4 idouble: 1 ifloat: 4 ildouble: 1 ldouble: 1 -Test "jn (2, 0x1.ffff62p+99) == -4.43860668048170034334926693188979974489e-16": +Test "jn (2, 0x1.ffff62p+99)": double: 2 float: 2 idouble: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (2, 2.4048255576957729) == 0.43175480701968038399746111312430703": +Test "jn (2, 2.4048255576957729)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, -1.0) == -0.0195633539826684059189053216217515083": +Test "jn (3, -1.0)": ildouble: 1 ldouble: 1 -Test "jn (3, 0.125) == 0.406503832554912875023029337653442868e-4": +Test "jn (3, 0.125)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 0.75) == 0.848438342327410884392755236884386804e-2": +Test "jn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "jn (3, 1.0) == 0.0195633539826684059189053216217515083": +Test "jn (3, 1.0)": ildouble: 1 ldouble: 1 -Test "jn (3, 10.0) == 0.0583793793051868123429354784103409563": +Test "jn (3, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "jn (3, 2.0) == 0.128943249474402051098793332969239835": +Test "jn (3, 2.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "jn (3, 2.4048255576957729) == 0.19899990535769083404042146764530813": +Test "jn (3, 2.4048255576957729)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "jn (4, 2.4048255576957729) == 0.647466661641779720084932282551219891E-1": +Test "jn (4, 2.4048255576957729)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "jn (5, 2.4048255576957729) == 0.163892432048058525099230549946147698E-1": +Test "jn (5, 2.4048255576957729)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 3 ldouble: 3 -Test "jn (6, 2.4048255576957729) == 0.34048184720278336646673682895929161E-2": +Test "jn (6, 2.4048255576957729)": double: 4 float: 3 idouble: 4 ifloat: 3 ildouble: 1 ldouble: 1 -Test "jn (7, 2.4048255576957729) == 0.60068836573295394221291569249883076E-3": +Test "jn (7, 2.4048255576957729)": double: 3 float: 5 idouble: 3 ifloat: 5 -Test "jn (8, 2.4048255576957729) == 0.92165786705344923232879022467054148E-4": +Test "jn (8, 2.4048255576957729)": double: 3 float: 2 idouble: 3 ifloat: 2 ildouble: 2 ldouble: 2 -Test "jn (9, 2.4048255576957729) == 0.12517270977961513005428966643852564E-4": +Test "jn (9, 2.4048255576957729)": double: 1 float: 2 idouble: 1 @@ -6731,15 +6743,15 @@ ildouble: 2 ldouble: 2 # lgamma -Test "lgamma (-0.5) == log(2*sqrt(pi))": +Test "lgamma (-0.5)": ildouble: 1 ldouble: 1 -Test "lgamma (0.7) == 0.260867246531666514385732417016759578": +Test "lgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "lgamma (1.2) == -0.853740900033158497197028392998854470e-1": +Test "lgamma (1.2)": double: 1 float: 2 idouble: 1 @@ -6748,1141 +6760,1161 @@ ildouble: 1 ldouble: 1 # log10 -Test "log10 (0.75) == -0.124938736608299953132449886193870744": +Test "log10 (0.75)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "log10 (e) == log10(e)": +Test "log10 (e)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # log1p -Test "log1p (-0.25) == -0.287682072451780927439219005993827432": +Test "log1p (-0.25)": float: 1 ifloat: 1 # pow -Test "pow (0x0.ffffffp0, -0x1p24) == 2.7182819094701610539628664526874952929416": +Test "pow (0x0.ffffffp0, -0x1p24)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "pow (0x0.ffffffp0, 0x1p24) == 0.3678794302077803437135155590023422899744": +Test "pow (0x0.ffffffp0, 0x1p24)": float: 1 ifloat: 1 -Test "pow (0x1.000002p0, 0x1p24) == 7.3890552180866447284268641248075832310141": +Test "pow (0x1.000002p0, 0x1p24)": float: 1 ifloat: 1 +# pow10 +Test "pow10 (-1)": +double: 1 +idouble: 1 +Test "pow10 (-305)": +double: 1 +idouble: 1 +Test "pow10 (-36)": +double: 1 +idouble: 1 +Test "pow10 (0.75)": +ildouble: 1 +ldouble: 1 +Test "pow10 (3)": +double: 1 +idouble: 1 +Test "pow10 (36)": +double: 1 +idouble: 1 + # pow_downward -Test "pow_downward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_downward (1.0625, 1.125)": ildouble: 1 ldouble: 1 -Test "pow_downward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_downward (1.5, 1.03125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # pow_towardzero -Test "pow_towardzero (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_towardzero (1.0625, 1.125)": ildouble: 1 ldouble: 1 -Test "pow_towardzero (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_towardzero (1.5, 1.03125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # pow_upward -Test "pow_upward (1.0625, 1.125) == 1.070582293028761362162622578677070098674": +Test "pow_upward (1.0625, 1.125)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "pow_upward (1.5, 1.03125) == 1.519127098714743184071644334163037684948": +Test "pow_upward (1.5, 1.03125)": ildouble: 1 ldouble: 1 # sin_downward -Test "sin_downward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_downward (1)": ildouble: 1 ldouble: 1 -Test "sin_downward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_downward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_downward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_downward (4)": ildouble: 1 ldouble: 1 -Test "sin_downward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_downward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_downward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_downward (6)": float: 1 ifloat: 1 -Test "sin_downward (7) == 0.6569865987187890903969990915936351779369": +Test "sin_downward (7)": ildouble: 1 ldouble: 1 -Test "sin_downward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_downward (8)": ildouble: 1 ldouble: 1 -Test "sin_downward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_downward (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_tonearest -Test "sin_tonearest (1) == 0.8414709848078965066525023216302989996226": +Test "sin_tonearest (1)": float: 1 ifloat: 1 -Test "sin_tonearest (10) == -0.5440211108893698134047476618513772816836": +Test "sin_tonearest (10)": ildouble: 1 ldouble: 1 -Test "sin_tonearest (4) == -0.7568024953079282513726390945118290941359": +Test "sin_tonearest (4)": ildouble: 1 ldouble: 1 -Test "sin_tonearest (9) == 0.4121184852417565697562725663524351793439": +Test "sin_tonearest (9)": ildouble: 1 ldouble: 1 # sin_towardzero -Test "sin_towardzero (1) == 0.8414709848078965066525023216302989996226": +Test "sin_towardzero (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_towardzero (10) == -0.5440211108893698134047476618513772816836": +Test "sin_towardzero (10)": float: 1 ifloat: 1 -Test "sin_towardzero (3) == 0.1411200080598672221007448028081102798469": +Test "sin_towardzero (3)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (4) == -0.7568024953079282513726390945118290941359": +Test "sin_towardzero (4)": float: 1 ifloat: 1 -Test "sin_towardzero (5) == -0.9589242746631384688931544061559939733525": +Test "sin_towardzero (5)": float: 1 ifloat: 1 -Test "sin_towardzero (6) == -0.2794154981989258728115554466118947596280": +Test "sin_towardzero (6)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (7) == 0.6569865987187890903969990915936351779369": +Test "sin_towardzero (7)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (8) == 0.9893582466233817778081235982452886721164": +Test "sin_towardzero (8)": ildouble: 1 ldouble: 1 -Test "sin_towardzero (9) == 0.4121184852417565697562725663524351793439": +Test "sin_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # sin_upward -Test "sin_upward (1) == 0.8414709848078965066525023216302989996226": +Test "sin_upward (1)": float: 1 ifloat: 1 -Test "sin_upward (10) == -0.5440211108893698134047476618513772816836": +Test "sin_upward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (2) == 0.9092974268256816953960198659117448427023": +Test "sin_upward (2)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "sin_upward (3) == 0.1411200080598672221007448028081102798469": +Test "sin_upward (3)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "sin_upward (4) == -0.7568024953079282513726390945118290941359": +Test "sin_upward (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (5) == -0.9589242746631384688931544061559939733525": +Test "sin_upward (5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "sin_upward (6) == -0.2794154981989258728115554466118947596280": +Test "sin_upward (6)": ildouble: 1 ldouble: 1 -Test "sin_upward (7) == 0.6569865987187890903969990915936351779369": +Test "sin_upward (7)": float: 1 ifloat: 1 -Test "sin_upward (8) == 0.9893582466233817778081235982452886721164": +Test "sin_upward (8)": float: 1 ifloat: 1 -Test "sin_upward (9) == 0.4121184852417565697562725663524351793439": +Test "sin_upward (9)": float: 1 ifloat: 1 # sincos -Test "sincos (0.80190127184058835, &sin_res, &cos_res) puts 0.69534156199418473 in cos_res": +Test "sincos (0.80190127184058835) extra output 2": double: 1 idouble: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.5 in cos_res": +Test "sincos (M_PI_6l*2.0) extra output 1": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "sincos (M_PI_6l*2.0, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in sin_res": +ildouble: 1 +ldouble: 1 +Test "sincos (M_PI_6l*2.0) extra output 2": double: 1 float: 1 idouble: 1 ifloat: 1 -ildouble: 1 -ldouble: 1 -Test "sincos (pi/6, &sin_res, &cos_res) puts 0.86602540378443864676372317075293616 in cos_res": +Test "sincos (pi/6) extra output 2": float: 1 ifloat: 1 # sinh_downward -Test "sinh_downward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_downward (22)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_downward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_downward (23)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_downward (24) == 13244561064.92173614705070540368454568168": +Test "sinh_downward (24)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # sinh_towardzero -Test "sinh_towardzero (22) == 1792456423.065795780701106568345764104225": +Test "sinh_towardzero (22)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_towardzero (23) == 4872401723.124451299966006944252978187305": +Test "sinh_towardzero (23)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "sinh_towardzero (24) == 13244561064.92173614705070540368454568168": +Test "sinh_towardzero (24)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 # sinh_upward -Test "sinh_upward (22) == 1792456423.065795780701106568345764104225": +Test "sinh_upward (22)": ildouble: 1 ldouble: 1 -Test "sinh_upward (23) == 4872401723.124451299966006944252978187305": +Test "sinh_upward (23)": ildouble: 1 ldouble: 1 # tan -Test "tan (0x1p16383) == 0.422722393732022337800504160054440141575": +Test "tan (0x1p16383)": ildouble: 1 ldouble: 1 -Test "tan (1e22) == -1.628778225606898878549375936939548513545": +Test "tan (1e22)": ildouble: 1 ldouble: 1 -Test "tan (pi/4) == 1": +Test "tan (pi/4)": double: 1 idouble: 1 # tan_downward -Test "tan_downward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_downward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_downward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_downward (2)": float: 1 ifloat: 1 -Test "tan_downward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_downward (3)": ildouble: 1 ldouble: 1 -Test "tan_downward (4) == 1.1578212823495775831373424182673239231198": +Test "tan_downward (4)": ildouble: 1 ldouble: 1 -Test "tan_downward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_downward (5)": ildouble: 1 ldouble: 1 -Test "tan_downward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_downward (6)": float: 1 ifloat: 1 -Test "tan_downward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_downward (8)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_downward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_downward (9)": float: 1 ifloat: 1 # tan_tonearest -Test "tan_tonearest (1) == 1.5574077246549022305069748074583601730873": +Test "tan_tonearest (1)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (2) == -2.1850398632615189916433061023136825434320": +Test "tan_tonearest (2)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (6) == -0.2910061913847491570536995888681755428312": +Test "tan_tonearest (6)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (8) == -6.7997114552203786999252627596086333648814": +Test "tan_tonearest (8)": ildouble: 1 ldouble: 1 -Test "tan_tonearest (9) == -0.4523156594418098405903708757987855343087": +Test "tan_tonearest (9)": ildouble: 1 ldouble: 1 # tan_towardzero -Test "tan_towardzero (1) == 1.5574077246549022305069748074583601730873": +Test "tan_towardzero (1)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (10) == 0.6483608274590866712591249330098086768169": +Test "tan_towardzero (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (2) == -2.1850398632615189916433061023136825434320": +Test "tan_towardzero (2)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (3) == -0.1425465430742778052956354105339134932261": +Test "tan_towardzero (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (4) == 1.1578212823495775831373424182673239231198": +Test "tan_towardzero (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_towardzero (5) == -3.3805150062465856369827058794473439087096": +Test "tan_towardzero (5)": float: 1 ifloat: 1 -Test "tan_towardzero (6) == -0.2910061913847491570536995888681755428312": +Test "tan_towardzero (6)": ildouble: 1 ldouble: 1 -Test "tan_towardzero (8) == -6.7997114552203786999252627596086333648814": +Test "tan_towardzero (8)": ildouble: 2 ldouble: 2 -Test "tan_towardzero (9) == -0.4523156594418098405903708757987855343087": +Test "tan_towardzero (9)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 # tan_upward -Test "tan_upward (1) == 1.5574077246549022305069748074583601730873": +Test "tan_upward (1)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (10) == 0.6483608274590866712591249330098086768169": +Test "tan_upward (10)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (2) == -2.1850398632615189916433061023136825434320": +Test "tan_upward (2)": ildouble: 1 ldouble: 1 -Test "tan_upward (3) == -0.1425465430742778052956354105339134932261": +Test "tan_upward (3)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tan_upward (5) == -3.3805150062465856369827058794473439087096": +Test "tan_upward (5)": float: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tan_upward (6) == -0.2910061913847491570536995888681755428312": +Test "tan_upward (6)": ildouble: 1 ldouble: 1 -Test "tan_upward (7) == 0.8714479827243187364564508896003135663222": +Test "tan_upward (7)": ildouble: 1 ldouble: 1 -Test "tan_upward (8) == -6.7997114552203786999252627596086333648814": +Test "tan_upward (8)": ildouble: 2 ldouble: 2 -Test "tan_upward (9) == -0.4523156594418098405903708757987855343087": +Test "tan_upward (9)": ildouble: 1 ldouble: 1 # tgamma -Test "tgamma (-0.5) == -2 sqrt (pi)": +Test "tgamma (-0.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x0.fffffffffffff8p0) == -9.0071992547409924227843350984672961392521e+15": +Test "tgamma (-0x0.fffffffffffff8p0)": double: 1 idouble: 1 -Test "tgamma (-0x0.ffffffffffffffffp0) == -1.8446744073709551616422784335098467139470e+19": +Test "tgamma (-0x0.ffffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x0.ffffffp0) == -1.6777216422784419250710305882992376932423e+07": +Test "tgamma (-0x0.ffffffp0)": float: 1 ifloat: 1 -Test "tgamma (-0x1.000002p0) == 8.3886075772158332060084424806449513922858e+06": +Test "tgamma (-0x1.000002p0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.0a32a2p+5) == 1.8125267978155035272941154746083439329912e-37": +Test "tgamma (-0x1.0a32a2p+5)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1.5800000080001p+7) == -3.1439271448823567326093363350637118195240e-304": +Test "tgamma (-0x1.5800000080001p+7)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x1.fffffffffffffp0) == 2.2517998136852484613921675492337776673289e+15": +Test "tgamma (-0x1.fffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x13.ffffep0) == 2.1550026214525536756224040483579183652119e-13": +Test "tgamma (-0x13.ffffep0)": float: 2 ifloat: 2 -Test "tgamma (-0x13.ffffffffffffffep0) == 2.3694367893405502075347562184931828448654e-01": +Test "tgamma (-0x13.ffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x13.ffffffffffffp0) == 1.1569515572952029402736625857313236848570e-04": +Test "tgamma (-0x13.ffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x14.000000000001p0) == -1.1569515572951781096476686854873801225397e-04": +Test "tgamma (-0x14.000000000001p0)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tgamma (-0x14.00002p0) == -2.1549777908265594916405421768142757507179e-13": +Test "tgamma (-0x14.00002p0)": float: 1 ifloat: 1 -Test "tgamma (-0x1d.ffffep0) == 1.9765721589464867957912772592816027583176e-27": +Test "tgamma (-0x1d.ffffep0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1d.ffffffffffffffep0) == 2.1732499046818166459536268654187775086902e-15": +Test "tgamma (-0x1d.ffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x1e.000000000000002p0) == -2.1732499046818166201837145753965837196590e-15": +Test "tgamma (-0x1e.000000000000002p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x1e.000000000001p0) == -1.0611571800204053929094168642022073530425e-18": +Test "tgamma (-0x1e.000000000001p0)": double: 3 idouble: 3 -Test "tgamma (-0x1e.00002p0) == -1.9765463890341964384070157599286498212650e-27": +Test "tgamma (-0x1e.00002p0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x1f4.00000000000002p0) == -2.9528489142763131406565394149878256133744e-1118": +Test "tgamma (-0x1f4.00000000000002p0)": ildouble: 3 ldouble: 3 -Test "tgamma (-0x1p-24) == -1.6777216577215723853867349114260580375249e+07": +Test "tgamma (-0x1p-24)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.0000000000000004p0) == -2.3058430092136939515386078324507664305064e+18": +Test "tgamma (-0x2.0000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.0000000000002p0) == -1.1258999068426235386078324507668462444260e+15": +Test "tgamma (-0x2.0000000000002p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.000004p0) == -2.0971515386080557574407223895988378776747e+06": +Test "tgamma (-0x2.000004p0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x2.fffffcp0) == -6.9905087601970247876992248591045142913324e+05": +Test "tgamma (-0x2.fffffcp0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x27.ffffcp0) == 3.2129279441390812141195076945616975790225e-43": +Test "tgamma (-0x27.ffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x27.fffffffffffep0) == 1.7249032006742266376460389310340465554361e-34": +Test "tgamma (-0x27.fffffffffffep0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.000000000002p0) == -1.7249032006741359094184881234822934593822e-34": +Test "tgamma (-0x28.000000000002p0)": double: 1 idouble: 1 -Test "tgamma (-0x28.00004p0) == -3.2128372159115252365699015758097981155793e-43": +Test "tgamma (-0x28.00004p0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.ffffcp0) == -7.8364103489619817539676737414096652170685e-45": +Test "tgamma (-0x28.ffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.fffffffffffep0) == -4.2070809772542120404320040128839297118648e-36": +Test "tgamma (-0x28.fffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x28.ffffffffffffffcp0) == -8.6161018414163982777002940498289948893044e-33": +Test "tgamma (-0x28.ffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.000000000000004p0) == 8.6161018414163980549537337663264762179535e-33": +Test "tgamma (-0x29.000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.000000000002p0) == 4.2070809772539892938717205103652583609422e-36": +Test "tgamma (-0x29.000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.00004p0) == 7.8361876024016854597745353972619195760515e-45": +Test "tgamma (-0x29.00004p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x29.ffffcp0) == 1.8658121573125798145204120066590953505132e-46": +Test "tgamma (-0x29.ffffcp0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x2a.00004p0) == -1.8657587834931410688246126853566488626385e-46": +Test "tgamma (-0x2a.00004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x2ed.fffffffffffffcp0) == 6.9801511765871818502006905472380418430269e-1817": +Test "tgamma (-0x2ed.fffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3.0000000000002p0) == 3.7529996894754112398038859470009084971438e+14": +Test "tgamma (-0x3.0000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3.000004p0) == 6.9905045731381300146131914617735687322025e+05": +Test "tgamma (-0x3.000004p0)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "tgamma (-0x3.fffffcp0) == 1.7476272942159602684441970627092458855771e+05": +Test "tgamma (-0x3.fffffcp0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-0x3.ffffffffffffep0) == 9.3824992236885396088236184658402406857503e+13": +Test "tgamma (-0x3.ffffffffffffep0)": double: 2 idouble: 2 -Test "tgamma (-0x3.fffffffffffffffcp0) == 1.9215358410114116272942156951799168638773e+17": +Test "tgamma (-0x3.fffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x31.fffffffffffep0) == 4.6273774273632946947805289899230181990085e-51": +Test "tgamma (-0x31.fffffffffffep0)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "tgamma (-0x32.000000000000004p0) == -9.4768689712397633101385547903658075308777e-48": +Test "tgamma (-0x32.000000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x32.000000000002p0) == -4.6273774273630367887073532197576655720178e-51": +Test "tgamma (-0x32.000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3e7.fffffffffffffcp0) == 4.4768809295877296071892611539415773519036e-2552": +Test "tgamma (-0x3e7.fffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x3e8.00000000000004p0) == -4.4768809295877261735541135972060089530309e-2552": +Test "tgamma (-0x3e8.00000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.0000000000000008p0) == -9.6076792050570581270578430482008313684602e+16": +Test "tgamma (-0x4.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.000008p0) == -8.7381270578483499672965708923121931082305e+04": +Test "tgamma (-0x4.000008p0)": float: 1 ifloat: 1 -Test "tgamma (-0x4.fffff8p0) == -1.7476280884325863043793087474680780379554e+04": +Test "tgamma (-0x4.fffff8p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x4.ffffffffffffcp0) == -9.3824992236885475509805702650262155809819e+12": +Test "tgamma (-0x4.ffffffffffffcp0)": double: 1 idouble: 1 -Test "tgamma (-0x4e2.00000000000008p0) == -5.4651488569236421026544487194247355967789e-3315": +Test "tgamma (-0x4e2.00000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.0000000000000008p0) == 1.9215358410114116252449019429734996071487e+16": +Test "tgamma (-0x5.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.0000000000004p0) == 9.3824992236885191156860964016850034672946e+12": +Test "tgamma (-0x5.0000000000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.000008p0) == 1.7476252449031389167286893378510439443844e+04": +Test "tgamma (-0x5.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x5.ffffffffffffcp0) == 1.5637498706147581566449098589862357835505e+12": +Test "tgamma (-0x5.ffffffffffffcp0)": double: 1 idouble: 1 -Test "tgamma (-0x5db.fffffffffffff8p0) == 1.8718211510339187689122114747834510481993e-4099": +Test "tgamma (-0x5db.fffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.0000000000000008p0) == -3.2025597350190193751766884234743511972877e+15": +Test "tgamma (-0x6.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x6.000008p0) == -2.9127085100239567622341538102130981196910e+03": +Test "tgamma (-0x6.000008p0)": float: 2 ifloat: 2 -Test "tgamma (-0x6.fffff8p0) == -4.1610198723079349791939054365613377035519e+02": +Test "tgamma (-0x6.fffff8p0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tgamma (-0x6.ffffffffffffcp0) == -2.2339283865925119357965832452642909859289e+11": +Test "tgamma (-0x6.ffffffffffffcp0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x63.fffffffffffcp0) == 7.5400833348840965463348754984345825364294e-145": +Test "tgamma (-0x63.fffffffffffcp0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x63.ffffffffffffff8p0) == 1.5442090669841618542494279375256856430049e-141": +Test "tgamma (-0x63.ffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x64.000000000000008p0) == -1.5442090669841617554527108348771968070612e-141": +Test "tgamma (-0x64.000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x64.000000000004p0) == -7.5400833348831085791638490135462230991587e-145": +Test "tgamma (-0x64.000000000004p0)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tgamma (-0x6d6.00000000000008p0) == -4.2925786447266421378134368786479937285900e-4902": +Test "tgamma (-0x6d6.00000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.0000000000000008p0) == 4.5750853357414562499689653215166468353753e+14": +Test "tgamma (-0x7.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.0000000000004p0) == 2.2339283865925039372192897706214475877342e+11": +Test "tgamma (-0x7.0000000000004p0)": double: 3 idouble: 3 ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.000008p0) == 4.1610118737306415004517215226199741948733e+02": +Test "tgamma (-0x7.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.fffff8p0) == 5.2012751504050764429534086402871289946986e+01": +Test "tgamma (-0x7.fffff8p0)": double: 3 float: 1 idouble: 3 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x7.ffffffffffffcp0) == 2.7924104832406402297655703264222230055898e+10": +Test "tgamma (-0x7.ffffffffffffcp0)": double: 3 idouble: 3 -Test "tgamma (-0x7.fffffffffffffff8p0) == 5.7188566696768203227694481100089533685959e+13": +Test "tgamma (-0x7.fffffffffffffff8p0)": ildouble: 4 ldouble: 4 -Test "tgamma (-0x8.000000000000001p0) == -2.8594283348384101534210280804672371201060e+13": +Test "tgamma (-0x8.000000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0x8.00001p0) == -2.6006296115134418896533598545925084576702e+01": +Test "tgamma (-0x8.00001p0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (-0x9.ffffffffffff8p0) == 1.5513391573559147700413058496716749249803e+08": +Test "tgamma (-0x9.ffffffffffff8p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0x9.fffffp0) == 2.8896008370721717567612135720915723136310e-01": +Test "tgamma (-0x9.fffffp0)": float: 1 ifloat: 1 -Test "tgamma (-0x95.fffffffffff8p0) == 6.1582369322723207086020016423767264008839e-250": +Test "tgamma (-0x95.fffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x95.ffffffffffffffp0) == 1.2612069237291916400144732227892704713839e-246": +Test "tgamma (-0x95.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0x96.000000000008p0) == -6.1582369322705655439003240743176243138734e-250": +Test "tgamma (-0x96.000000000008p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0xa.000000000000001p0) == -3.1771425942649001698860433502350057763905e+11": +Test "tgamma (-0xa.000000000000001p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xa.00001p0) == -2.8895878754728051776830454190076999107021e-01": +Test "tgamma (-0xa.00001p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-0xb4.ffffffffffffffp0) == -1.9816628031468191243385005680879281767694e-315": +Test "tgamma (-0xb4.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb5.00000000000001p0) == 1.9816628031468188382579700510291588022368e-315": +Test "tgamma (-0xb5.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb5.000000000008p0) == 9.6760879059888966544677044221698800670218e-319": +Test "tgamma (-0xb5.000000000008p0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xb5.ffffffffffffffp0) == 1.0888257160147357826865964233809723297472e-317": +Test "tgamma (-0xb5.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb6.00000000000001p0) == -1.0888257160147356253334423783317128355514e-317": +Test "tgamma (-0xb6.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb6.fffffffffff8p0) == -2.9052086428846935908287469917922960610289e-323": +Test "tgamma (-0xb6.fffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb6.ffffffffffffffp0) == -5.9498673006269714905418984659220067091260e-320": +Test "tgamma (-0xb6.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb7.fffffffffff8p0) == 1.5789177406982032823826953250736039527543e-325": +Test "tgamma (-0xb7.fffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xb7.ffffffffffffffp0) == 3.2336235329494410277123118903958061569834e-322": +Test "tgamma (-0xb7.ffffffffffffffp0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xb8.000000000008p0) == -1.5789177406977349925854817486109369828857e-325": +Test "tgamma (-0xb8.000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbb.ffffffffffffffp0) == 2.6730392040715350119087465463119939092815e-331": +Test "tgamma (-0xbb.ffffffffffffffp0)": ildouble: 2 ldouble: 2 -Test "tgamma (-0xbc.00000000000001p0) == -2.6730392040715346232108532050343031951651e-331": +Test "tgamma (-0xbc.00000000000001p0)": ildouble: 3 ldouble: 3 -Test "tgamma (-0xbd.00000000000001p0) == 1.4143064571807061497431633629389135273431e-333": +Test "tgamma (-0xbd.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbe.00000000000001p0) == -7.4437181956879271033676895858841525581153e-336": +Test "tgamma (-0xbe.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbe.ffffffffffffffp0) == -3.8972346574282346536709453101948570578636e-338": +Test "tgamma (-0xbe.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xbf.00000000000001p0) == 3.8972346574282340852496542564155275274974e-338": +Test "tgamma (-0xbf.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xf9.ffffffffffffffp0) == 2.2289142548411573883553287678043297937797e-476": +Test "tgamma (-0xf9.ffffffffffffffp0)": ildouble: 1 ldouble: 1 -Test "tgamma (-0xfa.00000000000001p0) == -2.2289142548411570466476165308364665814265e-476": +Test "tgamma (-0xfa.00000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (-1.5) == 2.3632718012073547030642233111215269103967e+00": +Test "tgamma (-1.5)": ildouble: 1 ldouble: 1 -Test "tgamma (-2.5) == -9.4530872048294188122568932444861076415869e-01": +Test "tgamma (-2.5)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "tgamma (-3.5) == 2.7008820585226910892162552127103164690248e-01": +Test "tgamma (-3.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (-4.5) == -6.0019601300504246427027893615784810422774e-02": +Test "tgamma (-4.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-5.5) == 1.0912654781909862986732344293779056440504e-02": +Test "tgamma (-5.5)": double: 1 idouble: 1 -Test "tgamma (-6.5) == -1.6788699664476712287280529682737009908468e-03": +Test "tgamma (-6.5)": float: 1 ifloat: 1 -Test "tgamma (-7.5) == 2.2384932885968949716374039576982679877958e-04": +Test "tgamma (-7.5)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-8.5) == -2.6335215159963470254557693619979623385833e-05": +Test "tgamma (-8.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (-9.5) == 2.7721279115751021320587045915768024616666e-06": +Test "tgamma (-9.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tgamma (0.5) == sqrt (pi)": +Test "tgamma (0.5)": float: 1 ifloat: 1 -Test "tgamma (0.7) == 1.29805533264755778568117117915281162": +Test "tgamma (0.7)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (0x1.fffffep0) == 9.9999994960018563231526611134590489120697e-01": +Test "tgamma (0x1.fffffep0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x1.fffffffffffffffep0) == 9.9999999999999999995416163053934024243282e-01": +Test "tgamma (0x1.fffffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x1.fffffffffffffp0) == 9.9999999999999990612301934456883679778984e-01": +Test "tgamma (0x1.fffffffffffffp0)": double: 1 idouble: 1 -Test "tgamma (0x1p-24) == 1.6777215422784394050795179874582764575261e+07": +Test "tgamma (0x1p-24)": float: 1 ifloat: 1 -Test "tgamma (0x1p-53) == 9.0071992547409914227843350984672492007618e+15": +Test "tgamma (0x1p-53)": double: 1 idouble: 1 -Test "tgamma (0x1p-64) == 1.8446744073709551615422784335098467139447e+19": +Test "tgamma (0x1p-64)": ildouble: 1 ldouble: 1 -Test "tgamma (0x2.0000000000002p0) == 1.0000000000000001877539613108624482361963e+00": +Test "tgamma (0x2.0000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x2.000004p0) == 1.0000001007996638509889062631687945799175e+00": +Test "tgamma (0x2.000004p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x2.30a43cp+4) == 3.4027979115654976101247558405326779640190e+38": +Test "tgamma (0x2.30a43cp+4)": double: 1 float: 2 idouble: 1 ifloat: 2 -Test "tgamma (0x2.fffffcp0) == 1.9999995599822108706107786027549565954046e+00": +Test "tgamma (0x2.fffffcp0)": float: 3 ifloat: 3 ildouble: 1 ldouble: 1 -Test "tgamma (0x2.ffffffffffffep0) == 1.9999999999999991804028675282128956223990e+00": +Test "tgamma (0x2.ffffffffffffep0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x3.0000000000002p0) == 2.0000000000000008195971324717875960213536e+00": +Test "tgamma (0x3.0000000000002p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x3.fffffcp0) == 5.9999982031095793171233994481968816873643e+00": +Test "tgamma (0x3.fffffcp0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x3.ffffffffffffep0) == 5.9999999999999966530301828845138185025345e+00": +Test "tgamma (0x3.ffffffffffffep0)": double: 1 idouble: 1 -Test "tgamma (0x3.fffffffffffffffcp0) == 5.9999999999999999983657373939865784753909e+00": +Test "tgamma (0x3.fffffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x4.0000000000000008p0) == 6.0000000000000000032685252120268430507939e+00": +Test "tgamma (0x4.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x4.0000000000004p0) == 6.0000000000000066939396342309789716341613e+00": +Test "tgamma (0x4.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x4.fffff8p0) == 2.3999982763857938712639837029547357501709e+01": +Test "tgamma (0x4.fffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x4.ffffffffffffcp0) == 2.3999999999999967895170944875373910918544e+01": +Test "tgamma (0x4.ffffffffffffcp0)": double: 1 idouble: 1 -Test "tgamma (0x4.fffffffffffffff8p0) == 2.3999999999999999984323813937927417165027e+01": +Test "tgamma (0x4.fffffffffffffff8p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x5.0000000000000008p0) == 2.4000000000000000015676186062072582846211e+01": +Test "tgamma (0x5.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x5.0000000000004p0) == 2.4000000000000032104829055124673225982803e+01": +Test "tgamma (0x5.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x5.000008p0) == 2.4000017236155647574166073485628713443799e+01": +Test "tgamma (0x5.000008p0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (0x5.fffff8p0) == 1.1999990237520611552119807476573441975106e+02": +Test "tgamma (0x5.fffff8p0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x5.ffffffffffffcp0) == 1.1999999999999981815957265157389249327533e+02": +Test "tgamma (0x5.ffffffffffffcp0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x6.0000000000000008p0) == 1.2000000000000000008878927116622375680433e+02": +Test "tgamma (0x6.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x6.0000000000004p0) == 1.2000000000000018184042734842640022086408e+02": +Test "tgamma (0x6.0000000000004p0)": double: 1 idouble: 1 -Test "tgamma (0x6.000008p0) == 1.2000009762487825358530770343720418162783e+02": +Test "tgamma (0x6.000008p0)": float: 2 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (0x6.fffff8p0) == 7.1999935703082425988147448928288557689866e+02": +Test "tgamma (0x6.fffff8p0)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x6.ffffffffffffcp0) == 7.1999999999999880237602554542848858572672e+02": +Test "tgamma (0x6.ffffffffffffcp0)": double: 3 idouble: 3 -Test "tgamma (0x7.0000000000000008p0) == 7.2000000000000000058477733127664675369681e+02": +Test "tgamma (0x7.0000000000000008p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x7.0000000000004p0) == 7.2000000000000119762397445457359071259652e+02": +Test "tgamma (0x7.0000000000004p0)": double: 4 idouble: 4 ildouble: 1 ldouble: 1 -Test "tgamma (0x7.000008p0) == 7.2000064296977505705636258629805621178587e+02": +Test "tgamma (0x7.000008p0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x7.fffff8p0) == 5.0399951558933225045148935487583089307135e+03": +Test "tgamma (0x7.fffff8p0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (0x7.ffffffffffffcp0) == 5.0399999999999909771437166339103165198442e+03": +Test "tgamma (0x7.ffffffffffffcp0)": double: 2 idouble: 2 -Test "tgamma (0x7.fffffffffffffff8p0) == 5.0399999999999999955943084553876474508520e+03": +Test "tgamma (0x7.fffffffffffffff8p0)": ildouble: 3 ldouble: 3 -Test "tgamma (0x8.000000000000001p0) == 5.0400000000000000088113830892247051102283e+03": +Test "tgamma (0x8.000000000000001p0)": ildouble: 1 ldouble: 1 -Test "tgamma (0x8.00001p0) == 5.0400096882277802019946778420223050233915e+03": +Test "tgamma (0x8.00001p0)": double: 2 idouble: 2 ildouble: 1 ldouble: 1 -Test "tgamma (0xa.b9fd72b0fb238p+4) == 1.7976931348622298700886249281842651388250e+308": +Test "tgamma (0xa.b9fd72b0fb238p+4)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "tgamma (10) == 362880": +Test "tgamma (10)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (18.5) == 1.4986120533153361177371791123515513270334e+15": +Test "tgamma (18.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (19.5) == 2.7724322986333718178137813578503699550119e+16": +Test "tgamma (19.5)": double: 2 idouble: 2 -Test "tgamma (2.5) == 1.3293403881791370204736256125058588870982e+00": +Test "tgamma (2.5)": float: 2 ifloat: 2 -Test "tgamma (23.5) == 5.3613035875444147334274983856108155717836e+21": +Test "tgamma (23.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (29.5) == 1.6348125198274266444378807806868221866931e+30": +Test "tgamma (29.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (3) == 2": +Test "tgamma (3)": float: 1 ifloat: 1 -Test "tgamma (3.5) == 3.3233509704478425511840640312646472177454e+00": +Test "tgamma (3.5)": float: 2 ifloat: 2 -Test "tgamma (30.5) == 4.8226969334909086010917483030261254507447e+31": +Test "tgamma (30.5)": float: 1 ifloat: 1 -Test "tgamma (32.5) == 4.6334060788513904384988971821323500268029e+34": +Test "tgamma (32.5)": ildouble: 1 ldouble: 1 -Test "tgamma (33.5) == 1.5058569756267018925121415841930137587110e+36": +Test "tgamma (33.5)": float: 1 ifloat: 1 -Test "tgamma (34.5) == 5.0446208683494513399156743070465960916817e+37": +Test "tgamma (34.5)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "tgamma (4) == 6": +Test "tgamma (4)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (4.5) == 1.1631728396567448929144224109426265262109e+01": +Test "tgamma (4.5)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "tgamma (5.5) == 5.2342777784553520181149008492418193679490e+01": +Test "tgamma (5.5)": ildouble: 1 ldouble: 1 -Test "tgamma (6) == 120": +Test "tgamma (6)": float: 1 ifloat: 1 -Test "tgamma (6.5) == 2.8788527781504436099631954670830006523720e+02": +Test "tgamma (6.5)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (7) == 720": +Test "tgamma (7)": double: 1 idouble: 1 -Test "tgamma (7.5) == 1.8712543057977883464760770536039504240418e+03": +Test "tgamma (7.5)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "tgamma (8) == 5040": +Test "tgamma (8)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (8.5) == 1.4034407293483412598570577902029628180313e+04": +Test "tgamma (8.5)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "tgamma (9) == 40320": +Test "tgamma (9)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "tgamma (9.5) == 1.1929246199460900708784991216725183953266e+05": +Test "tgamma (9.5)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 # y0 -Test "y0 (0.125) == -1.38968062514384052915582277745018693": +Test "y0 (0.125)": ildouble: 1 ldouble: 1 -Test "y0 (0x1.3ffp+74) == 1.818984347516051243459467456433028748678e-12": +Test "y0 (0x1.3ffp+74)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1.ff00000000002p+840) == 1.846591691699331493194965158699937660696e-127": +Test "y0 (0x1.ff00000000002p+840)": double: 1 idouble: 1 -Test "y0 (0x1p-10) == -4.4865150767109739412411806297168793661098": +Test "y0 (0x1p-10)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-110) == -4.861363632869203777249475899390797503250e+1": +Test "y0 (0x1p-110)": double: 1 idouble: 1 -Test "y0 (0x1p-20) == -8.8992283012125827603076426611387876938160": +Test "y0 (0x1p-20)": float: 1 ifloat: 1 -Test "y0 (0x1p-30) == -1.3311940304267782826037118027401817264906e+1": +Test "y0 (0x1p-30)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (0x1p-40) == -1.7724652307320814696990854700366226762563e+1": +Test "y0 (0x1p-40)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p-50) == -2.2137364310373846564919987139743760738155e+1": +Test "y0 (0x1p-50)": float: 1 ifloat: 1 -Test "y0 (0x1p-70) == -3.0962788316479910300778244424468159753887e+1": +Test "y0 (0x1p-70)": double: 1 idouble: 1 -Test "y0 (0x1p-80) == -3.5375500319532942168707373066828113573541e+1": +Test "y0 (0x1p-80)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "y0 (0x1p16382) == 8.0839224448726336195866026476176740513439e-2467": +Test "y0 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "y0 (1.0) == 0.0882569642156769579829267660235151628": +Test "y0 (1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (1.5) == 0.382448923797758843955068554978089862": +Test "y0 (1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "y0 (10.0) == 0.0556711672835993914244598774101900481": +Test "y0 (10.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y0 (8.0) == 0.223521489387566220527323400498620359": +Test "y0 (8.0)": double: 1 float: 1 idouble: 1 @@ -7891,43 +7923,43 @@ ildouble: 1 ldouble: 1 # y1 -Test "y1 (0.125) == -5.19993611253477499595928744876579921": +Test "y1 (0.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "y1 (0x1.001000001p+593) == 3.927269966354206207832593635798954916263e-90": +Test "y1 (0x1.001000001p+593)": ildouble: 2 ldouble: 2 -Test "y1 (0x1.27e204p+99) == -8.881610148467797208469612080785210013461e-16": +Test "y1 (0x1.27e204p+99)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (0x1p-10) == -6.5190099301063115047395187618929589514382e+02": +Test "y1 (0x1p-10)": double: 1 idouble: 1 -Test "y1 (0x1p16382) == 1.2193782500509000574176799046642541129387e-2466": +Test "y1 (0x1p16382)": ildouble: 1 ldouble: 1 -Test "y1 (1.5) == -0.412308626973911295952829820633445323": +Test "y1 (1.5)": float: 1 ifloat: 1 -Test "y1 (10.0) == 0.249015424206953883923283474663222803": +Test "y1 (10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "y1 (2.0) == -0.107032431540937546888370772277476637": +Test "y1 (2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "y1 (8.0) == -0.158060461731247494255555266187483550": +Test "y1 (8.0)": double: 1 float: 2 idouble: 1 @@ -7936,101 +7968,101 @@ ildouble: 1 ldouble: 1 # yn -Test "yn (0, 0.125) == -1.38968062514384052915582277745018693": +Test "yn (0, 0.125)": ildouble: 1 ldouble: 1 -Test "yn (0, 1.0) == 0.0882569642156769579829267660235151628": +Test "yn (0, 1.0)": double: 2 float: 1 idouble: 2 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 1.5) == 0.382448923797758843955068554978089862": +Test "yn (0, 1.5)": double: 2 float: 1 idouble: 2 ifloat: 1 -Test "yn (0, 10.0) == 0.0556711672835993914244598774101900481": +Test "yn (0, 10.0)": float: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (0, 8.0) == 0.223521489387566220527323400498620359": +Test "yn (0, 8.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 0.125) == -5.19993611253477499595928744876579921": +Test "yn (1, 0.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 1.5) == -0.412308626973911295952829820633445323": +Test "yn (1, 1.5)": float: 1 ifloat: 1 -Test "yn (1, 10.0) == 0.249015424206953883923283474663222803": +Test "yn (1, 10.0)": double: 3 float: 1 idouble: 3 ifloat: 1 -Test "yn (1, 2.0) == -0.107032431540937546888370772277476637": +Test "yn (1, 2.0)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 1 ldouble: 1 -Test "yn (1, 8.0) == -0.158060461731247494255555266187483550": +Test "yn (1, 8.0)": double: 1 float: 2 idouble: 1 ifloat: 2 ildouble: 1 ldouble: 1 -Test "yn (10, 0.125) == -127057845771019398.252538486899753195": +Test "yn (10, 0.125)": double: 1 idouble: 1 ildouble: 2 ldouble: 2 -Test "yn (10, 0.75) == -2133501638.90573424452445412893839236": +Test "yn (10, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 4 ldouble: 4 -Test "yn (10, 1.0) == -121618014.278689189288130426667971145": +Test "yn (10, 1.0)": double: 1 idouble: 1 -Test "yn (10, 10.0) == -0.359814152183402722051986577343560609": +Test "yn (10, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (10, 2.0) == -129184.542208039282635913145923304214": +Test "yn (10, 2.0)": double: 2 idouble: 2 -Test "yn (3, 0.125) == -2612.69757350066712600220955744091741": +Test "yn (3, 0.125)": double: 1 idouble: 1 ildouble: 1 ldouble: 1 -Test "yn (3, 0.75) == -12.9877176234475433186319774484809207": +Test "yn (3, 0.75)": double: 1 float: 1 idouble: 1 ifloat: 1 ildouble: 2 ldouble: 2 -Test "yn (3, 10.0) == -0.251362657183837329779204747654240998": +Test "yn (3, 10.0)": double: 1 float: 1 idouble: 1 ifloat: 1 -Test "yn (3, 2.0) == -1.12778377684042778608158395773179238": +Test "yn (3, 2.0)": double: 1 idouble: 1 @@ -8564,6 +8596,10 @@ ildouble: 1 ldouble: 1 Function: "gamma": +double: 1 +float: 2 +idouble: 1 +ifloat: 2 ildouble: 1 ldouble: 1 @@ -8621,6 +8657,12 @@ ifloat: 1 ildouble: 1 ldouble: 1 +Function: "pow10": +double: 1 +idouble: 1 +ildouble: 1 +ldouble: 1 + Function: "pow_downward": float: 1 ifloat: 1 diff --git a/libc/sysdeps/x86_64/memset.S b/libc/sysdeps/x86_64/memset.S index b393efe44..6c69f4b44 100644 --- a/libc/sysdeps/x86_64/memset.S +++ b/libc/sysdeps/x86_64/memset.S @@ -19,17 +19,31 @@ #include <sysdep.h> -#define __STOS_LOWER_BOUNDARY $8192 -#define __STOS_UPPER_BOUNDARY $65536 +#ifndef ALIGN +# define ALIGN(n) .p2align n +#endif .text #if !defined NOT_IN_libc ENTRY(__bzero) - mov %rsi,%rdx /* Adjust parameter. */ - xorl %esi,%esi /* Fill with 0s. */ - jmp L(memset_entry) + movq %rdi, %rax /* Set return value. */ + movq %rsi, %rdx /* Set n. */ + pxor %xmm8, %xmm8 + jmp L(entry_from_bzero) END(__bzero) weak_alias (__bzero, bzero) + +/* Like memset but takes additional parameter with return value. */ +ENTRY(__memset_tail) + movq %rcx, %rax /* Set return value. */ + + movd %esi, %xmm8 + punpcklbw %xmm8, %xmm8 + punpcklwd %xmm8, %xmm8 + pshufd $0, %xmm8, %xmm8 + + jmp L(entry_from_bzero) +END(__memset_tail) #endif #if defined PIC && !defined NOT_IN_libc @@ -38,1318 +52,79 @@ ENTRY_CHK (__memset_chk) jb HIDDEN_JUMPTARGET (__chk_fail) END_CHK (__memset_chk) #endif -ENTRY (memset) -L(memset_entry): - cmp $0x1,%rdx - mov %rdi,%rax /* memset returns the dest address. */ - jne L(ck2) - mov %sil,(%rdi) - retq -L(ck2): - mov $0x101010101010101,%r9 - mov %rdx,%r8 - movzbq %sil,%rdx - imul %r9,%rdx -L(now_dw_aligned): - cmp $0x90,%r8 - ja L(ck_mem_ops_method) -L(now_dw_aligned_small): - add %r8,%rdi -#ifndef PIC - lea L(setPxQx)(%rip),%r11 - jmpq *(%r11,%r8,8) -#else - lea L(Got0)(%rip),%r11 - lea L(setPxQx)(%rip),%rcx - movswq (%rcx,%r8,2),%rcx - lea (%rcx,%r11,1),%r11 - jmpq *%r11 -#endif - -L(Got0): - retq - - .pushsection .rodata - .balign 16 -#ifndef PIC -L(setPxQx): - .quad L(Got0), L(P1Q0), L(P2Q0), L(P3Q0) - .quad L(P4Q0), L(P5Q0), L(P6Q0), L(P7Q0) - .quad L(P0Q1), L(P1Q1), L(P2Q1), L(P3Q1) - .quad L(P4Q1), L(P5Q1), L(P6Q1), L(P7Q1) - .quad L(P0Q2), L(P1Q2), L(P2Q2), L(P3Q2) - .quad L(P4Q2), L(P5Q2), L(P6Q2), L(P7Q2) - .quad L(P0Q3), L(P1Q3), L(P2Q3), L(P3Q3) - .quad L(P4Q3), L(P5Q3), L(P6Q3), L(P7Q3) - .quad L(P0Q4), L(P1Q4), L(P2Q4), L(P3Q4) - .quad L(P4Q4), L(P5Q4), L(P6Q4), L(P7Q4) - .quad L(P0Q5), L(P1Q5), L(P2Q5), L(P3Q5) - .quad L(P4Q5), L(P5Q5), L(P6Q5), L(P7Q5) - .quad L(P0Q6), L(P1Q6), L(P2Q6), L(P3Q6) - .quad L(P4Q6), L(P5Q6), L(P6Q6), L(P7Q6) - .quad L(P0Q7), L(P1Q7), L(P2Q7), L(P3Q7) - .quad L(P4Q7), L(P5Q7), L(P6Q7), L(P7Q7) - .quad L(P0Q8), L(P1Q8), L(P2Q8), L(P3Q8) - .quad L(P4Q8), L(P5Q8), L(P6Q8), L(P7Q8) - .quad L(P0Q9), L(P1Q9), L(P2Q9), L(P3Q9) - .quad L(P4Q9), L(P5Q9), L(P6Q9), L(P7Q9) - .quad L(P0QA), L(P1QA), L(P2QA), L(P3QA) - .quad L(P4QA), L(P5QA), L(P6QA), L(P7QA) - .quad L(P0QB), L(P1QB), L(P2QB), L(P3QB) - .quad L(P4QB), L(P5QB), L(P6QB), L(P7QB) - .quad L(P0QC), L(P1QC), L(P2QC), L(P3QC) - .quad L(P4QC), L(P5QC), L(P6QC), L(P7QC) - .quad L(P0QD), L(P1QD), L(P2QD), L(P3QD) - .quad L(P4QD), L(P5QD), L(P6QD), L(P7QD) - .quad L(P0QE), L(P1QE), L(P2QE), L(P3QE) - .quad L(P4QE), L(P5QE), L(P6QE), L(P7QE) - .quad L(P0QF), L(P1QF), L(P2QF), L(P3QF) - .quad L(P4QF), L(P5QF), L(P6QF), L(P7QF) - .quad L(P0QG), L(P1QG), L(P2QG), L(P3QG) - .quad L(P4QG), L(P5QG), L(P6QG), L(P7QG) - .quad L(P0QH), L(P1QH), L(P2QH), L(P3QH) - .quad L(P4QH), L(P5QH), L(P6QH), L(P7QH) - .quad L(P0QI) -# ifdef USE_EXTRA_TABLE - .quad L(P1QI), L(P2QI), L(P3QI), L(P4QI) - .quad L(P5QI), L(P6QI), L(P7QI) -# endif -#else -L(setPxQx): - .short L(Got0)-L(Got0) - .short L(P1Q0)-L(Got0) - .short L(P2Q0)-L(Got0) - .short L(P3Q0)-L(Got0) - .short L(P4Q0)-L(Got0) - .short L(P5Q0)-L(Got0) - .short L(P6Q0)-L(Got0) - .short L(P7Q0)-L(Got0) - - .short L(P0Q1)-L(Got0) - .short L(P1Q1)-L(Got0) - .short L(P2Q1)-L(Got0) - .short L(P3Q1)-L(Got0) - .short L(P4Q1)-L(Got0) - .short L(P5Q1)-L(Got0) - .short L(P6Q1)-L(Got0) - .short L(P7Q1)-L(Got0) - - .short L(P0Q2)-L(Got0) - .short L(P1Q2)-L(Got0) - .short L(P2Q2)-L(Got0) - .short L(P3Q2)-L(Got0) - .short L(P4Q2)-L(Got0) - .short L(P5Q2)-L(Got0) - .short L(P6Q2)-L(Got0) - .short L(P7Q2)-L(Got0) - - .short L(P0Q3)-L(Got0) - .short L(P1Q3)-L(Got0) - .short L(P2Q3)-L(Got0) - .short L(P3Q3)-L(Got0) - .short L(P4Q3)-L(Got0) - .short L(P5Q3)-L(Got0) - .short L(P6Q3)-L(Got0) - .short L(P7Q3)-L(Got0) - - .short L(P0Q4)-L(Got0) - .short L(P1Q4)-L(Got0) - .short L(P2Q4)-L(Got0) - .short L(P3Q4)-L(Got0) - .short L(P4Q4)-L(Got0) - .short L(P5Q4)-L(Got0) - .short L(P6Q4)-L(Got0) - .short L(P7Q4)-L(Got0) - - .short L(P0Q5)-L(Got0) - .short L(P1Q5)-L(Got0) - .short L(P2Q5)-L(Got0) - .short L(P3Q5)-L(Got0) - .short L(P4Q5)-L(Got0) - .short L(P5Q5)-L(Got0) - .short L(P6Q5)-L(Got0) - .short L(P7Q5)-L(Got0) - - .short L(P0Q6)-L(Got0) - .short L(P1Q6)-L(Got0) - .short L(P2Q6)-L(Got0) - .short L(P3Q6)-L(Got0) - .short L(P4Q6)-L(Got0) - .short L(P5Q6)-L(Got0) - .short L(P6Q6)-L(Got0) - .short L(P7Q6)-L(Got0) - - .short L(P0Q7)-L(Got0) - .short L(P1Q7)-L(Got0) - .short L(P2Q7)-L(Got0) - .short L(P3Q7)-L(Got0) - .short L(P4Q7)-L(Got0) - .short L(P5Q7)-L(Got0) - .short L(P6Q7)-L(Got0) - .short L(P7Q7)-L(Got0) - - .short L(P0Q8)-L(Got0) - .short L(P1Q8)-L(Got0) - .short L(P2Q8)-L(Got0) - .short L(P3Q8)-L(Got0) - .short L(P4Q8)-L(Got0) - .short L(P5Q8)-L(Got0) - .short L(P6Q8)-L(Got0) - .short L(P7Q8)-L(Got0) - - .short L(P0Q9)-L(Got0) - .short L(P1Q9)-L(Got0) - .short L(P2Q9)-L(Got0) - .short L(P3Q9)-L(Got0) - .short L(P4Q9)-L(Got0) - .short L(P5Q9)-L(Got0) - .short L(P6Q9)-L(Got0) - .short L(P7Q9)-L(Got0) - - .short L(P0QA)-L(Got0) - .short L(P1QA)-L(Got0) - .short L(P2QA)-L(Got0) - .short L(P3QA)-L(Got0) - .short L(P4QA)-L(Got0) - .short L(P5QA)-L(Got0) - .short L(P6QA)-L(Got0) - .short L(P7QA)-L(Got0) - - .short L(P0QB)-L(Got0) - .short L(P1QB)-L(Got0) - .short L(P2QB)-L(Got0) - .short L(P3QB)-L(Got0) - .short L(P4QB)-L(Got0) - .short L(P5QB)-L(Got0) - .short L(P6QB)-L(Got0) - .short L(P7QB)-L(Got0) - - .short L(P0QC)-L(Got0) - .short L(P1QC)-L(Got0) - .short L(P2QC)-L(Got0) - .short L(P3QC)-L(Got0) - .short L(P4QC)-L(Got0) - .short L(P5QC)-L(Got0) - .short L(P6QC)-L(Got0) - .short L(P7QC)-L(Got0) - - .short L(P0QD)-L(Got0) - .short L(P1QD)-L(Got0) - .short L(P2QD)-L(Got0) - .short L(P3QD)-L(Got0) - .short L(P4QD)-L(Got0) - .short L(P5QD)-L(Got0) - .short L(P6QD)-L(Got0) - .short L(P7QD)-L(Got0) - - .short L(P0QE)-L(Got0) - .short L(P1QE)-L(Got0) - .short L(P2QE)-L(Got0) - .short L(P3QE)-L(Got0) - .short L(P4QE)-L(Got0) - .short L(P5QE)-L(Got0) - .short L(P6QE)-L(Got0) - .short L(P7QE)-L(Got0) - - .short L(P0QF)-L(Got0) - .short L(P1QF)-L(Got0) - .short L(P2QF)-L(Got0) - .short L(P3QF)-L(Got0) - .short L(P4QF)-L(Got0) - .short L(P5QF)-L(Got0) - .short L(P6QF)-L(Got0) - .short L(P7QF)-L(Got0) - - .short L(P0QG)-L(Got0) - .short L(P1QG)-L(Got0) - .short L(P2QG)-L(Got0) - .short L(P3QG)-L(Got0) - .short L(P4QG)-L(Got0) - .short L(P5QG)-L(Got0) - .short L(P6QG)-L(Got0) - .short L(P7QG)-L(Got0) - - .short L(P0QH)-L(Got0) - .short L(P1QH)-L(Got0) - .short L(P2QH)-L(Got0) - .short L(P3QH)-L(Got0) - .short L(P4QH)-L(Got0) - .short L(P5QH)-L(Got0) - .short L(P6QH)-L(Got0) - .short L(P7QH)-L(Got0) - - .short L(P0QI)-L(Got0) -# ifdef USE_EXTRA_TABLE - .short L(P1QI)-L(Got0) - .short L(P2QI)-L(Got0) - .short L(P3QI)-L(Got0) - .short L(P4QI)-L(Got0) - .short L(P5QI)-L(Got0) - .short L(P6QI)-L(Got0) - .short L(P7QI)-L(Got0) -# endif -#endif - .popsection - - .balign 16 -#ifdef USE_EXTRA_TABLE -L(P1QI): mov %rdx,-0x91(%rdi) -#endif -L(P1QH): mov %rdx,-0x89(%rdi) -L(P1QG): mov %rdx,-0x81(%rdi) -# .balign 16 -L(P1QF): mov %rdx,-0x79(%rdi) -L(P1QE): mov %rdx,-0x71(%rdi) -L(P1QD): mov %rdx,-0x69(%rdi) -L(P1QC): mov %rdx,-0x61(%rdi) -L(P1QB): mov %rdx,-0x59(%rdi) -L(P1QA): mov %rdx,-0x51(%rdi) -L(P1Q9): mov %rdx,-0x49(%rdi) -L(P1Q8): mov %rdx,-0x41(%rdi) -L(P1Q7): mov %rdx,-0x39(%rdi) -L(P1Q6): mov %rdx,-0x31(%rdi) -L(P1Q5): mov %rdx,-0x29(%rdi) -L(P1Q4): mov %rdx,-0x21(%rdi) -L(P1Q3): mov %rdx,-0x19(%rdi) -L(P1Q2): mov %rdx,-0x11(%rdi) -L(P1Q1): mov %rdx,-0x9(%rdi) -L(P1Q0): mov %dl,-0x1(%rdi) - retq - - .balign 16 -L(P0QI): mov %rdx,-0x90(%rdi) -L(P0QH): mov %rdx,-0x88(%rdi) -# .balign 16 -L(P0QG): mov %rdx,-0x80(%rdi) -L(P0QF): mov %rdx,-0x78(%rdi) -L(P0QE): mov %rdx,-0x70(%rdi) -L(P0QD): mov %rdx,-0x68(%rdi) -L(P0QC): mov %rdx,-0x60(%rdi) -L(P0QB): mov %rdx,-0x58(%rdi) -L(P0QA): mov %rdx,-0x50(%rdi) -L(P0Q9): mov %rdx,-0x48(%rdi) -L(P0Q8): mov %rdx,-0x40(%rdi) -L(P0Q7): mov %rdx,-0x38(%rdi) -L(P0Q6): mov %rdx,-0x30(%rdi) -L(P0Q5): mov %rdx,-0x28(%rdi) -L(P0Q4): mov %rdx,-0x20(%rdi) -L(P0Q3): mov %rdx,-0x18(%rdi) -L(P0Q2): mov %rdx,-0x10(%rdi) -L(P0Q1): mov %rdx,-0x8(%rdi) -L(P0Q0): retq - - - .balign 16 -#ifdef USE_EXTRA_TABLE -L(P2QI): mov %rdx,-0x92(%rdi) -#endif -L(P2QH): mov %rdx,-0x8a(%rdi) -L(P2QG): mov %rdx,-0x82(%rdi) -# .balign 16 -L(P2QF): mov %rdx,-0x7a(%rdi) -L(P2QE): mov %rdx,-0x72(%rdi) -L(P2QD): mov %rdx,-0x6a(%rdi) -L(P2QC): mov %rdx,-0x62(%rdi) -L(P2QB): mov %rdx,-0x5a(%rdi) -L(P2QA): mov %rdx,-0x52(%rdi) -L(P2Q9): mov %rdx,-0x4a(%rdi) -L(P2Q8): mov %rdx,-0x42(%rdi) -L(P2Q7): mov %rdx,-0x3a(%rdi) -L(P2Q6): mov %rdx,-0x32(%rdi) -L(P2Q5): mov %rdx,-0x2a(%rdi) -L(P2Q4): mov %rdx,-0x22(%rdi) -L(P2Q3): mov %rdx,-0x1a(%rdi) -L(P2Q2): mov %rdx,-0x12(%rdi) -L(P2Q1): mov %rdx,-0xa(%rdi) -L(P2Q0): mov %dx,-0x2(%rdi) - retq - - .balign 16 -#ifdef USE_EXTRA_TABLE -L(P3QI): mov %rdx,-0x93(%rdi) -#endif -L(P3QH): mov %rdx,-0x8b(%rdi) -L(P3QG): mov %rdx,-0x83(%rdi) -# .balign 16 -L(P3QF): mov %rdx,-0x7b(%rdi) -L(P3QE): mov %rdx,-0x73(%rdi) -L(P3QD): mov %rdx,-0x6b(%rdi) -L(P3QC): mov %rdx,-0x63(%rdi) -L(P3QB): mov %rdx,-0x5b(%rdi) -L(P3QA): mov %rdx,-0x53(%rdi) -L(P3Q9): mov %rdx,-0x4b(%rdi) -L(P3Q8): mov %rdx,-0x43(%rdi) -L(P3Q7): mov %rdx,-0x3b(%rdi) -L(P3Q6): mov %rdx,-0x33(%rdi) -L(P3Q5): mov %rdx,-0x2b(%rdi) -L(P3Q4): mov %rdx,-0x23(%rdi) -L(P3Q3): mov %rdx,-0x1b(%rdi) -L(P3Q2): mov %rdx,-0x13(%rdi) -L(P3Q1): mov %rdx,-0xb(%rdi) -L(P3Q0): mov %dx,-0x3(%rdi) - mov %dl,-0x1(%rdi) - retq - - .balign 16 -#ifdef USE_EXTRA_TABLE -L(P4QI): mov %rdx,-0x94(%rdi) -#endif -L(P4QH): mov %rdx,-0x8c(%rdi) -L(P4QG): mov %rdx,-0x84(%rdi) -# .balign 16 -L(P4QF): mov %rdx,-0x7c(%rdi) -L(P4QE): mov %rdx,-0x74(%rdi) -L(P4QD): mov %rdx,-0x6c(%rdi) -L(P4QC): mov %rdx,-0x64(%rdi) -L(P4QB): mov %rdx,-0x5c(%rdi) -L(P4QA): mov %rdx,-0x54(%rdi) -L(P4Q9): mov %rdx,-0x4c(%rdi) -L(P4Q8): mov %rdx,-0x44(%rdi) -L(P4Q7): mov %rdx,-0x3c(%rdi) -L(P4Q6): mov %rdx,-0x34(%rdi) -L(P4Q5): mov %rdx,-0x2c(%rdi) -L(P4Q4): mov %rdx,-0x24(%rdi) -L(P4Q3): mov %rdx,-0x1c(%rdi) -L(P4Q2): mov %rdx,-0x14(%rdi) -L(P4Q1): mov %rdx,-0xc(%rdi) -L(P4Q0): mov %edx,-0x4(%rdi) - retq - - .balign 16 -#ifdef USE_EXTRA_TABLE -L(P5QI): mov %rdx,-0x95(%rdi) -#endif -L(P5QH): mov %rdx,-0x8d(%rdi) -L(P5QG): mov %rdx,-0x85(%rdi) -# .balign 16 -L(P5QF): mov %rdx,-0x7d(%rdi) -L(P5QE): mov %rdx,-0x75(%rdi) -L(P5QD): mov %rdx,-0x6d(%rdi) -L(P5QC): mov %rdx,-0x65(%rdi) -L(P5QB): mov %rdx,-0x5d(%rdi) -L(P5QA): mov %rdx,-0x55(%rdi) -L(P5Q9): mov %rdx,-0x4d(%rdi) -L(P5Q8): mov %rdx,-0x45(%rdi) -L(P5Q7): mov %rdx,-0x3d(%rdi) -L(P5Q6): mov %rdx,-0x35(%rdi) -L(P5Q5): mov %rdx,-0x2d(%rdi) -L(P5Q4): mov %rdx,-0x25(%rdi) -L(P5Q3): mov %rdx,-0x1d(%rdi) -L(P5Q2): mov %rdx,-0x15(%rdi) -L(P5Q1): mov %rdx,-0xd(%rdi) -L(P5Q0): mov %edx,-0x5(%rdi) - mov %dl,-0x1(%rdi) - retq - - .balign 16 -#ifdef USE_EXTRA_TABLE -L(P6QI): mov %rdx,-0x96(%rdi) -#endif -L(P6QH): mov %rdx,-0x8e(%rdi) -L(P6QG): mov %rdx,-0x86(%rdi) -# .balign 16 -L(P6QF): mov %rdx,-0x7e(%rdi) -L(P6QE): mov %rdx,-0x76(%rdi) -L(P6QD): mov %rdx,-0x6e(%rdi) -L(P6QC): mov %rdx,-0x66(%rdi) -L(P6QB): mov %rdx,-0x5e(%rdi) -L(P6QA): mov %rdx,-0x56(%rdi) -L(P6Q9): mov %rdx,-0x4e(%rdi) -L(P6Q8): mov %rdx,-0x46(%rdi) -L(P6Q7): mov %rdx,-0x3e(%rdi) -L(P6Q6): mov %rdx,-0x36(%rdi) -L(P6Q5): mov %rdx,-0x2e(%rdi) -L(P6Q4): mov %rdx,-0x26(%rdi) -L(P6Q3): mov %rdx,-0x1e(%rdi) -L(P6Q2): mov %rdx,-0x16(%rdi) -L(P6Q1): mov %rdx,-0xe(%rdi) -L(P6Q0): mov %edx,-0x6(%rdi) - mov %dx,-0x2(%rdi) - retq - - .balign 16 -#ifdef USE_EXTRA_TABLE -L(P7QI): mov %rdx,-0x97(%rdi) -#endif -L(P7QH): mov %rdx,-0x8f(%rdi) -L(P7QG): mov %rdx,-0x87(%rdi) -# .balign 16 -L(P7QF): mov %rdx,-0x7f(%rdi) -L(P7QE): mov %rdx,-0x77(%rdi) -L(P7QD): mov %rdx,-0x6f(%rdi) -L(P7QC): mov %rdx,-0x67(%rdi) -L(P7QB): mov %rdx,-0x5f(%rdi) -L(P7QA): mov %rdx,-0x57(%rdi) -L(P7Q9): mov %rdx,-0x4f(%rdi) -L(P7Q8): mov %rdx,-0x47(%rdi) -L(P7Q7): mov %rdx,-0x3f(%rdi) -L(P7Q6): mov %rdx,-0x37(%rdi) -L(P7Q5): mov %rdx,-0x2f(%rdi) -L(P7Q4): mov %rdx,-0x27(%rdi) -L(P7Q3): mov %rdx,-0x1f(%rdi) -L(P7Q2): mov %rdx,-0x17(%rdi) -L(P7Q1): mov %rdx,-0xf(%rdi) -L(P7Q0): mov %edx,-0x7(%rdi) - mov %dx,-0x3(%rdi) - mov %dl,-0x1(%rdi) - retq - - .balign 16 -L(ck_mem_ops_method): - -# align to 16 byte boundary first - #test $0xf,%rdi - #jz L(aligned_now) - mov $0x10,%r10 - mov %rdi,%r9 - and $0xf,%r9 - sub %r9,%r10 - and $0xf,%r10 - add %r10,%rdi - sub %r10,%r8 -#ifndef PIC - lea L(AliPxQx)(%rip),%r11 - jmpq *(%r11,%r10,8) -#else - lea L(aligned_now)(%rip), %r11 - lea L(AliPxQx)(%rip),%rcx - movswq (%rcx,%r10,2),%rcx - lea (%rcx,%r11,1),%r11 - jmpq *%r11 -#endif - - .pushsection .rodata - .balign 16 -#ifndef PIC -L(AliPxQx): - .quad L(aligned_now), L(A1Q0), L(A2Q0), L(A3Q0) - .quad L(A4Q0), L(A5Q0), L(A6Q0), L(A7Q0) - .quad L(A0Q1), L(A1Q1), L(A2Q1), L(A3Q1) - .quad L(A4Q1), L(A5Q1), L(A6Q1), L(A7Q1) -#else -L(AliPxQx): - .short L(aligned_now)-L(aligned_now) - .short L(A1Q0)-L(aligned_now) - .short L(A2Q0)-L(aligned_now) - .short L(A3Q0)-L(aligned_now) - .short L(A4Q0)-L(aligned_now) - .short L(A5Q0)-L(aligned_now) - .short L(A6Q0)-L(aligned_now) - .short L(A7Q0)-L(aligned_now) - - .short L(A0Q1)-L(aligned_now) - .short L(A1Q1)-L(aligned_now) - .short L(A2Q1)-L(aligned_now) - .short L(A3Q1)-L(aligned_now) - .short L(A4Q1)-L(aligned_now) - .short L(A5Q1)-L(aligned_now) - .short L(A6Q1)-L(aligned_now) - .short L(A7Q1)-L(aligned_now) -#endif - .popsection - - .balign 16 -L(A5Q1): mov %dl,-0xd(%rdi) -L(A4Q1): mov %edx,-0xc(%rdi) -L(A0Q1): mov %rdx,-0x8(%rdi) -L(A0Q0): jmp L(aligned_now) - - .balign 16 -L(A1Q1): mov %dl,-0x9(%rdi) - mov %rdx,-0x8(%rdi) - jmp L(aligned_now) - - .balign 16 -L(A1Q0): mov %dl,-0x1(%rdi) - jmp L(aligned_now) - - .balign 16 -L(A3Q1): mov %dl,-0xb(%rdi) -L(A2Q1): mov %dx,-0xa(%rdi) - mov %rdx,-0x8(%rdi) - jmp L(aligned_now) - - .balign 16 -L(A3Q0): mov %dl,-0x3(%rdi) -L(A2Q0): mov %dx,-0x2(%rdi) - jmp L(aligned_now) - - .balign 16 -L(A5Q0): mov %dl,-0x5(%rdi) -L(A4Q0): mov %edx,-0x4(%rdi) - jmp L(aligned_now) - - .balign 16 -L(A7Q1): mov %dl,-0xf(%rdi) -L(A6Q1): mov %dx,-0xe(%rdi) - mov %edx,-0xc(%rdi) - mov %rdx,-0x8(%rdi) - jmp L(aligned_now) - - .balign 16 -L(A7Q0): mov %dl,-0x7(%rdi) -L(A6Q0): mov %dx,-0x6(%rdi) - mov %edx,-0x4(%rdi) - -#ifndef USE_MULTIARCH - jmp L(aligned_now) - -L(SSE_pre): -#else -L(aligned_now): -#endif -#if !defined USE_MULTIARCH || defined USE_SSE2 - # fill RegXMM0 with the pattern - movd %rdx,%xmm0 - punpcklqdq %xmm0,%xmm0 - - cmp $0xb0,%r8 # 176 - jae L(byte32sse2_pre) - - add %r8,%rdi -# ifndef PIC - lea L(SSExDx)(%rip),%r9 - jmpq *(%r9,%r8,8) -# else - lea L(SSE0Q0)(%rip),%r9 - lea L(SSExDx)(%rip),%rcx - movswq (%rcx,%r8,2),%rcx - lea (%rcx,%r9,1),%r9 - jmpq *%r9 -# endif - -L(SSE0QB): movdqa %xmm0,-0xb0(%rdi) -L(SSE0QA): movdqa %xmm0,-0xa0(%rdi) -L(SSE0Q9): movdqa %xmm0,-0x90(%rdi) -L(SSE0Q8): movdqa %xmm0,-0x80(%rdi) -L(SSE0Q7): movdqa %xmm0,-0x70(%rdi) -L(SSE0Q6): movdqa %xmm0,-0x60(%rdi) -L(SSE0Q5): movdqa %xmm0,-0x50(%rdi) -L(SSE0Q4): movdqa %xmm0,-0x40(%rdi) -L(SSE0Q3): movdqa %xmm0,-0x30(%rdi) -L(SSE0Q2): movdqa %xmm0,-0x20(%rdi) -L(SSE0Q1): movdqa %xmm0,-0x10(%rdi) -L(SSE0Q0): retq - -L(SSE1QB): movdqa %xmm0,-0xb1(%rdi) -L(SSE1QA): movdqa %xmm0,-0xa1(%rdi) -L(SSE1Q9): movdqa %xmm0,-0x91(%rdi) -L(SSE1Q8): movdqa %xmm0,-0x81(%rdi) -L(SSE1Q7): movdqa %xmm0,-0x71(%rdi) -L(SSE1Q6): movdqa %xmm0,-0x61(%rdi) -L(SSE1Q5): movdqa %xmm0,-0x51(%rdi) -L(SSE1Q4): movdqa %xmm0,-0x41(%rdi) -L(SSE1Q3): movdqa %xmm0,-0x31(%rdi) -L(SSE1Q2): movdqa %xmm0,-0x21(%rdi) -L(SSE1Q1): movdqa %xmm0,-0x11(%rdi) -L(SSE1Q0): mov %dl,-0x1(%rdi) - retq - -L(SSE2QB): movdqa %xmm0,-0xb2(%rdi) -L(SSE2QA): movdqa %xmm0,-0xa2(%rdi) -L(SSE2Q9): movdqa %xmm0,-0x92(%rdi) -L(SSE2Q8): movdqa %xmm0,-0x82(%rdi) -L(SSE2Q7): movdqa %xmm0,-0x72(%rdi) -L(SSE2Q6): movdqa %xmm0,-0x62(%rdi) -L(SSE2Q5): movdqa %xmm0,-0x52(%rdi) -L(SSE2Q4): movdqa %xmm0,-0x42(%rdi) -L(SSE2Q3): movdqa %xmm0,-0x32(%rdi) -L(SSE2Q2): movdqa %xmm0,-0x22(%rdi) -L(SSE2Q1): movdqa %xmm0,-0x12(%rdi) -L(SSE2Q0): mov %dx,-0x2(%rdi) - retq - -L(SSE3QB): movdqa %xmm0,-0xb3(%rdi) -L(SSE3QA): movdqa %xmm0,-0xa3(%rdi) -L(SSE3Q9): movdqa %xmm0,-0x93(%rdi) -L(SSE3Q8): movdqa %xmm0,-0x83(%rdi) -L(SSE3Q7): movdqa %xmm0,-0x73(%rdi) -L(SSE3Q6): movdqa %xmm0,-0x63(%rdi) -L(SSE3Q5): movdqa %xmm0,-0x53(%rdi) -L(SSE3Q4): movdqa %xmm0,-0x43(%rdi) -L(SSE3Q3): movdqa %xmm0,-0x33(%rdi) -L(SSE3Q2): movdqa %xmm0,-0x23(%rdi) -L(SSE3Q1): movdqa %xmm0,-0x13(%rdi) -L(SSE3Q0): mov %dx,-0x3(%rdi) - mov %dl,-0x1(%rdi) - retq - -L(SSE4QB): movdqa %xmm0,-0xb4(%rdi) -L(SSE4QA): movdqa %xmm0,-0xa4(%rdi) -L(SSE4Q9): movdqa %xmm0,-0x94(%rdi) -L(SSE4Q8): movdqa %xmm0,-0x84(%rdi) -L(SSE4Q7): movdqa %xmm0,-0x74(%rdi) -L(SSE4Q6): movdqa %xmm0,-0x64(%rdi) -L(SSE4Q5): movdqa %xmm0,-0x54(%rdi) -L(SSE4Q4): movdqa %xmm0,-0x44(%rdi) -L(SSE4Q3): movdqa %xmm0,-0x34(%rdi) -L(SSE4Q2): movdqa %xmm0,-0x24(%rdi) -L(SSE4Q1): movdqa %xmm0,-0x14(%rdi) -L(SSE4Q0): mov %edx,-0x4(%rdi) - retq - -L(SSE5QB): movdqa %xmm0,-0xb5(%rdi) -L(SSE5QA): movdqa %xmm0,-0xa5(%rdi) -L(SSE5Q9): movdqa %xmm0,-0x95(%rdi) -L(SSE5Q8): movdqa %xmm0,-0x85(%rdi) -L(SSE5Q7): movdqa %xmm0,-0x75(%rdi) -L(SSE5Q6): movdqa %xmm0,-0x65(%rdi) -L(SSE5Q5): movdqa %xmm0,-0x55(%rdi) -L(SSE5Q4): movdqa %xmm0,-0x45(%rdi) -L(SSE5Q3): movdqa %xmm0,-0x35(%rdi) -L(SSE5Q2): movdqa %xmm0,-0x25(%rdi) -L(SSE5Q1): movdqa %xmm0,-0x15(%rdi) -L(SSE5Q0): mov %edx,-0x5(%rdi) - mov %dl,-0x1(%rdi) - retq - - -L(SSE6QB): movdqa %xmm0,-0xb6(%rdi) -L(SSE6QA): movdqa %xmm0,-0xa6(%rdi) -L(SSE6Q9): movdqa %xmm0,-0x96(%rdi) -L(SSE6Q8): movdqa %xmm0,-0x86(%rdi) -L(SSE6Q7): movdqa %xmm0,-0x76(%rdi) -L(SSE6Q6): movdqa %xmm0,-0x66(%rdi) -L(SSE6Q5): movdqa %xmm0,-0x56(%rdi) -L(SSE6Q4): movdqa %xmm0,-0x46(%rdi) -L(SSE6Q3): movdqa %xmm0,-0x36(%rdi) -L(SSE6Q2): movdqa %xmm0,-0x26(%rdi) -L(SSE6Q1): movdqa %xmm0,-0x16(%rdi) -L(SSE6Q0): mov %edx,-0x6(%rdi) - mov %dx,-0x2(%rdi) - retq - -L(SSE7QB): movdqa %xmm0,-0xb7(%rdi) -L(SSE7QA): movdqa %xmm0,-0xa7(%rdi) -L(SSE7Q9): movdqa %xmm0,-0x97(%rdi) -L(SSE7Q8): movdqa %xmm0,-0x87(%rdi) -L(SSE7Q7): movdqa %xmm0,-0x77(%rdi) -L(SSE7Q6): movdqa %xmm0,-0x67(%rdi) -L(SSE7Q5): movdqa %xmm0,-0x57(%rdi) -L(SSE7Q4): movdqa %xmm0,-0x47(%rdi) -L(SSE7Q3): movdqa %xmm0,-0x37(%rdi) -L(SSE7Q2): movdqa %xmm0,-0x27(%rdi) -L(SSE7Q1): movdqa %xmm0,-0x17(%rdi) -L(SSE7Q0): mov %edx,-0x7(%rdi) - mov %dx,-0x3(%rdi) - mov %dl,-0x1(%rdi) - retq - -L(SSE8QB): movdqa %xmm0,-0xb8(%rdi) -L(SSE8QA): movdqa %xmm0,-0xa8(%rdi) -L(SSE8Q9): movdqa %xmm0,-0x98(%rdi) -L(SSE8Q8): movdqa %xmm0,-0x88(%rdi) -L(SSE8Q7): movdqa %xmm0,-0x78(%rdi) -L(SSE8Q6): movdqa %xmm0,-0x68(%rdi) -L(SSE8Q5): movdqa %xmm0,-0x58(%rdi) -L(SSE8Q4): movdqa %xmm0,-0x48(%rdi) -L(SSE8Q3): movdqa %xmm0,-0x38(%rdi) -L(SSE8Q2): movdqa %xmm0,-0x28(%rdi) -L(SSE8Q1): movdqa %xmm0,-0x18(%rdi) -L(SSE8Q0): mov %rdx,-0x8(%rdi) - retq - -L(SSE9QB): movdqa %xmm0,-0xb9(%rdi) -L(SSE9QA): movdqa %xmm0,-0xa9(%rdi) -L(SSE9Q9): movdqa %xmm0,-0x99(%rdi) -L(SSE9Q8): movdqa %xmm0,-0x89(%rdi) -L(SSE9Q7): movdqa %xmm0,-0x79(%rdi) -L(SSE9Q6): movdqa %xmm0,-0x69(%rdi) -L(SSE9Q5): movdqa %xmm0,-0x59(%rdi) -L(SSE9Q4): movdqa %xmm0,-0x49(%rdi) -L(SSE9Q3): movdqa %xmm0,-0x39(%rdi) -L(SSE9Q2): movdqa %xmm0,-0x29(%rdi) -L(SSE9Q1): movdqa %xmm0,-0x19(%rdi) -L(SSE9Q0): mov %rdx,-0x9(%rdi) - mov %dl,-0x1(%rdi) - retq - -L(SSE10QB): movdqa %xmm0,-0xba(%rdi) -L(SSE10QA): movdqa %xmm0,-0xaa(%rdi) -L(SSE10Q9): movdqa %xmm0,-0x9a(%rdi) -L(SSE10Q8): movdqa %xmm0,-0x8a(%rdi) -L(SSE10Q7): movdqa %xmm0,-0x7a(%rdi) -L(SSE10Q6): movdqa %xmm0,-0x6a(%rdi) -L(SSE10Q5): movdqa %xmm0,-0x5a(%rdi) -L(SSE10Q4): movdqa %xmm0,-0x4a(%rdi) -L(SSE10Q3): movdqa %xmm0,-0x3a(%rdi) -L(SSE10Q2): movdqa %xmm0,-0x2a(%rdi) -L(SSE10Q1): movdqa %xmm0,-0x1a(%rdi) -L(SSE10Q0): mov %rdx,-0xa(%rdi) - mov %dx,-0x2(%rdi) - retq - -L(SSE11QB): movdqa %xmm0,-0xbb(%rdi) -L(SSE11QA): movdqa %xmm0,-0xab(%rdi) -L(SSE11Q9): movdqa %xmm0,-0x9b(%rdi) -L(SSE11Q8): movdqa %xmm0,-0x8b(%rdi) -L(SSE11Q7): movdqa %xmm0,-0x7b(%rdi) -L(SSE11Q6): movdqa %xmm0,-0x6b(%rdi) -L(SSE11Q5): movdqa %xmm0,-0x5b(%rdi) -L(SSE11Q4): movdqa %xmm0,-0x4b(%rdi) -L(SSE11Q3): movdqa %xmm0,-0x3b(%rdi) -L(SSE11Q2): movdqa %xmm0,-0x2b(%rdi) -L(SSE11Q1): movdqa %xmm0,-0x1b(%rdi) -L(SSE11Q0): mov %rdx,-0xb(%rdi) - mov %dx,-0x3(%rdi) - mov %dl,-0x1(%rdi) - retq - -L(SSE12QB): movdqa %xmm0,-0xbc(%rdi) -L(SSE12QA): movdqa %xmm0,-0xac(%rdi) -L(SSE12Q9): movdqa %xmm0,-0x9c(%rdi) -L(SSE12Q8): movdqa %xmm0,-0x8c(%rdi) -L(SSE12Q7): movdqa %xmm0,-0x7c(%rdi) -L(SSE12Q6): movdqa %xmm0,-0x6c(%rdi) -L(SSE12Q5): movdqa %xmm0,-0x5c(%rdi) -L(SSE12Q4): movdqa %xmm0,-0x4c(%rdi) -L(SSE12Q3): movdqa %xmm0,-0x3c(%rdi) -L(SSE12Q2): movdqa %xmm0,-0x2c(%rdi) -L(SSE12Q1): movdqa %xmm0,-0x1c(%rdi) -L(SSE12Q0): mov %rdx,-0xc(%rdi) - mov %edx,-0x4(%rdi) - retq - -L(SSE13QB): movdqa %xmm0,-0xbd(%rdi) -L(SSE13QA): movdqa %xmm0,-0xad(%rdi) -L(SSE13Q9): movdqa %xmm0,-0x9d(%rdi) -L(SSE13Q8): movdqa %xmm0,-0x8d(%rdi) -L(SSE13Q7): movdqa %xmm0,-0x7d(%rdi) -L(SSE13Q6): movdqa %xmm0,-0x6d(%rdi) -L(SSE13Q5): movdqa %xmm0,-0x5d(%rdi) -L(SSE13Q4): movdqa %xmm0,-0x4d(%rdi) -L(SSE13Q3): movdqa %xmm0,-0x3d(%rdi) -L(SSE13Q2): movdqa %xmm0,-0x2d(%rdi) -L(SSE13Q1): movdqa %xmm0,-0x1d(%rdi) -L(SSE13Q0): mov %rdx,-0xd(%rdi) - mov %edx,-0x5(%rdi) - mov %dl,-0x1(%rdi) - retq - -L(SSE14QB): movdqa %xmm0,-0xbe(%rdi) -L(SSE14QA): movdqa %xmm0,-0xae(%rdi) -L(SSE14Q9): movdqa %xmm0,-0x9e(%rdi) -L(SSE14Q8): movdqa %xmm0,-0x8e(%rdi) -L(SSE14Q7): movdqa %xmm0,-0x7e(%rdi) -L(SSE14Q6): movdqa %xmm0,-0x6e(%rdi) -L(SSE14Q5): movdqa %xmm0,-0x5e(%rdi) -L(SSE14Q4): movdqa %xmm0,-0x4e(%rdi) -L(SSE14Q3): movdqa %xmm0,-0x3e(%rdi) -L(SSE14Q2): movdqa %xmm0,-0x2e(%rdi) -L(SSE14Q1): movdqa %xmm0,-0x1e(%rdi) -L(SSE14Q0): mov %rdx,-0xe(%rdi) - mov %edx,-0x6(%rdi) - mov %dx,-0x2(%rdi) - retq - -L(SSE15QB): movdqa %xmm0,-0xbf(%rdi) -L(SSE15QA): movdqa %xmm0,-0xaf(%rdi) -L(SSE15Q9): movdqa %xmm0,-0x9f(%rdi) -L(SSE15Q8): movdqa %xmm0,-0x8f(%rdi) -L(SSE15Q7): movdqa %xmm0,-0x7f(%rdi) -L(SSE15Q6): movdqa %xmm0,-0x6f(%rdi) -L(SSE15Q5): movdqa %xmm0,-0x5f(%rdi) -L(SSE15Q4): movdqa %xmm0,-0x4f(%rdi) -L(SSE15Q3): movdqa %xmm0,-0x3f(%rdi) -L(SSE15Q2): movdqa %xmm0,-0x2f(%rdi) -L(SSE15Q1): movdqa %xmm0,-0x1f(%rdi) -L(SSE15Q0): mov %rdx,-0xf(%rdi) - mov %edx,-0x7(%rdi) - mov %dx,-0x3(%rdi) - mov %dl,-0x1(%rdi) - retq - - .balign 16 -L(byte32sse2_pre): - - mov __x86_shared_cache_size(%rip),%r9d # The largest cache size - cmp %r9,%r8 - ja L(sse2_nt_move_pre) - #jmp L(byte32sse2) - .balign 16 -L(byte32sse2): - lea -0x80(%r8),%r8 # 128 - cmp $0x80,%r8 # 128 - movdqa %xmm0,(%rdi) - movdqa %xmm0,0x10(%rdi) - movdqa %xmm0,0x20(%rdi) - movdqa %xmm0,0x30(%rdi) - movdqa %xmm0,0x40(%rdi) - movdqa %xmm0,0x50(%rdi) - movdqa %xmm0,0x60(%rdi) - movdqa %xmm0,0x70(%rdi) - - lea 0x80(%rdi),%rdi - jae L(byte32sse2) - add %r8,%rdi -# ifndef PIC - lea L(SSExDx)(%rip),%r11 - jmpq *(%r11,%r8,8) -# else - lea L(SSE0Q0)(%rip),%r11 - lea L(SSExDx)(%rip),%rcx - movswq (%rcx,%r8,2),%rcx - lea (%rcx,%r11,1),%r11 - jmpq *%r11 -# endif - - .balign 16 -L(sse2_nt_move_pre): - cmp $0x0,%r9 - je L(byte32sse2) - jmp L(sse2_nt_move) - - .balign 16 -L(sse2_nt_move): - lea -0x80(%r8),%r8 - cmp $0x80,%r8 - - movntdq %xmm0,(%rdi) - movntdq %xmm0,0x10(%rdi) - movntdq %xmm0,0x20(%rdi) - movntdq %xmm0,0x30(%rdi) - movntdq %xmm0,0x40(%rdi) - movntdq %xmm0,0x50(%rdi) - movntdq %xmm0,0x60(%rdi) - movntdq %xmm0,0x70(%rdi) - - lea 0x80(%rdi),%rdi - jae L(sse2_nt_move) - sfence - add %r8,%rdi -# ifndef PIC - lea L(SSExDx)(%rip),%r11 - jmpq *(%r11,%r8,8) -# else - lea L(SSE0Q0)(%rip),%r11 - lea L(SSExDx)(%rip),%rcx - movswq (%rcx,%r8,2),%rcx - lea (%rcx,%r11,1),%r11 - jmpq *%r11 -# endif - - .pushsection .rodata - .balign 16 -# ifndef PIC -L(SSExDx): - .quad L(SSE0Q0), L(SSE1Q0), L(SSE2Q0), L(SSE3Q0) - .quad L(SSE4Q0), L(SSE5Q0), L(SSE6Q0), L(SSE7Q0) - .quad L(SSE8Q0), L(SSE9Q0), L(SSE10Q0), L(SSE11Q0) - .quad L(SSE12Q0), L(SSE13Q0), L(SSE14Q0), L(SSE15Q0) - .quad L(SSE0Q1), L(SSE1Q1), L(SSE2Q1), L(SSE3Q1) - .quad L(SSE4Q1), L(SSE5Q1), L(SSE6Q1), L(SSE7Q1) - .quad L(SSE8Q1), L(SSE9Q1), L(SSE10Q1), L(SSE11Q1) - .quad L(SSE12Q1), L(SSE13Q1), L(SSE14Q1), L(SSE15Q1) - .quad L(SSE0Q2), L(SSE1Q2), L(SSE2Q2), L(SSE3Q2) - .quad L(SSE4Q2), L(SSE5Q2), L(SSE6Q2), L(SSE7Q2) - .quad L(SSE8Q2), L(SSE9Q2), L(SSE10Q2), L(SSE11Q2) - .quad L(SSE12Q2), L(SSE13Q2), L(SSE14Q2), L(SSE15Q2) - .quad L(SSE0Q3), L(SSE1Q3), L(SSE2Q3), L(SSE3Q3) - .quad L(SSE4Q3), L(SSE5Q3), L(SSE6Q3), L(SSE7Q3) - .quad L(SSE8Q3), L(SSE9Q3), L(SSE10Q3), L(SSE11Q3) - .quad L(SSE12Q3), L(SSE13Q3), L(SSE14Q3), L(SSE15Q3) - .quad L(SSE0Q4), L(SSE1Q4), L(SSE2Q4), L(SSE3Q4) - .quad L(SSE4Q4), L(SSE5Q4), L(SSE6Q4), L(SSE7Q4) - .quad L(SSE8Q4), L(SSE9Q4), L(SSE10Q4), L(SSE11Q4) - .quad L(SSE12Q4), L(SSE13Q4), L(SSE14Q4), L(SSE15Q4) - .quad L(SSE0Q5), L(SSE1Q5), L(SSE2Q5), L(SSE3Q5) - .quad L(SSE4Q5), L(SSE5Q5), L(SSE6Q5), L(SSE7Q5) - .quad L(SSE8Q5), L(SSE9Q5), L(SSE10Q5), L(SSE11Q5) - .quad L(SSE12Q5), L(SSE13Q5), L(SSE14Q5), L(SSE15Q5) - .quad L(SSE0Q6), L(SSE1Q6), L(SSE2Q6), L(SSE3Q6) - .quad L(SSE4Q6), L(SSE5Q6), L(SSE6Q6), L(SSE7Q6) - .quad L(SSE8Q6), L(SSE9Q6), L(SSE10Q6), L(SSE11Q6) - .quad L(SSE12Q6), L(SSE13Q6), L(SSE14Q6), L(SSE15Q6) - .quad L(SSE0Q7), L(SSE1Q7), L(SSE2Q7), L(SSE3Q7) - .quad L(SSE4Q7), L(SSE5Q7), L(SSE6Q7), L(SSE7Q7) - .quad L(SSE8Q7), L(SSE9Q7), L(SSE10Q7), L(SSE11Q7) - .quad L(SSE12Q7), L(SSE13Q7), L(SSE14Q7), L(SSE15Q7) - .quad L(SSE0Q8), L(SSE1Q8), L(SSE2Q8), L(SSE3Q8) - .quad L(SSE4Q8), L(SSE5Q8), L(SSE6Q8), L(SSE7Q8) - .quad L(SSE8Q8), L(SSE9Q8), L(SSE10Q8), L(SSE11Q8) - .quad L(SSE12Q8), L(SSE13Q8), L(SSE14Q8), L(SSE15Q8) - .quad L(SSE0Q9), L(SSE1Q9), L(SSE2Q9), L(SSE3Q9) - .quad L(SSE4Q9), L(SSE5Q9), L(SSE6Q9), L(SSE7Q9) - .quad L(SSE8Q9), L(SSE9Q9), L(SSE10Q9), L(SSE11Q9) - .quad L(SSE12Q9), L(SSE13Q9), L(SSE14Q9), L(SSE15Q9) - .quad L(SSE0QA), L(SSE1QA), L(SSE2QA), L(SSE3QA) - .quad L(SSE4QA), L(SSE5QA), L(SSE6QA), L(SSE7QA) - .quad L(SSE8QA), L(SSE9QA), L(SSE10QA), L(SSE11QA) - .quad L(SSE12QA), L(SSE13QA), L(SSE14QA), L(SSE15QA) - .quad L(SSE0QB), L(SSE1QB), L(SSE2QB), L(SSE3QB) - .quad L(SSE4QB), L(SSE5QB), L(SSE6QB), L(SSE7QB) - .quad L(SSE8QB), L(SSE9QB), L(SSE10QB), L(SSE11QB) - .quad L(SSE12QB), L(SSE13QB), L(SSE14QB), L(SSE15QB) -# else -L(SSExDx): - .short L(SSE0Q0) -L(SSE0Q0) - .short L(SSE1Q0) -L(SSE0Q0) - .short L(SSE2Q0) -L(SSE0Q0) - .short L(SSE3Q0) -L(SSE0Q0) - .short L(SSE4Q0) -L(SSE0Q0) - .short L(SSE5Q0) -L(SSE0Q0) - .short L(SSE6Q0) -L(SSE0Q0) - .short L(SSE7Q0) -L(SSE0Q0) - - .short L(SSE8Q0) -L(SSE0Q0) - .short L(SSE9Q0) -L(SSE0Q0) - .short L(SSE10Q0)-L(SSE0Q0) - .short L(SSE11Q0)-L(SSE0Q0) - .short L(SSE12Q0)-L(SSE0Q0) - .short L(SSE13Q0)-L(SSE0Q0) - .short L(SSE14Q0)-L(SSE0Q0) - .short L(SSE15Q0)-L(SSE0Q0) - - .short L(SSE0Q1) -L(SSE0Q0) - .short L(SSE1Q1) -L(SSE0Q0) - .short L(SSE2Q1) -L(SSE0Q0) - .short L(SSE3Q1) -L(SSE0Q0) - .short L(SSE4Q1) -L(SSE0Q0) - .short L(SSE5Q1) -L(SSE0Q0) - .short L(SSE6Q1) -L(SSE0Q0) - .short L(SSE7Q1) -L(SSE0Q0) - - .short L(SSE8Q1) -L(SSE0Q0) - .short L(SSE9Q1) -L(SSE0Q0) - .short L(SSE10Q1)-L(SSE0Q0) - .short L(SSE11Q1)-L(SSE0Q0) - .short L(SSE12Q1)-L(SSE0Q0) - .short L(SSE13Q1)-L(SSE0Q0) - .short L(SSE14Q1)-L(SSE0Q0) - .short L(SSE15Q1)-L(SSE0Q0) - - .short L(SSE0Q2) -L(SSE0Q0) - .short L(SSE1Q2) -L(SSE0Q0) - .short L(SSE2Q2) -L(SSE0Q0) - .short L(SSE3Q2) -L(SSE0Q0) - .short L(SSE4Q2) -L(SSE0Q0) - .short L(SSE5Q2) -L(SSE0Q0) - .short L(SSE6Q2) -L(SSE0Q0) - .short L(SSE7Q2) -L(SSE0Q0) - - .short L(SSE8Q2) -L(SSE0Q0) - .short L(SSE9Q2) -L(SSE0Q0) - .short L(SSE10Q2)-L(SSE0Q0) - .short L(SSE11Q2)-L(SSE0Q0) - .short L(SSE12Q2)-L(SSE0Q0) - .short L(SSE13Q2)-L(SSE0Q0) - .short L(SSE14Q2)-L(SSE0Q0) - .short L(SSE15Q2)-L(SSE0Q0) - - .short L(SSE0Q3) -L(SSE0Q0) - .short L(SSE1Q3) -L(SSE0Q0) - .short L(SSE2Q3) -L(SSE0Q0) - .short L(SSE3Q3) -L(SSE0Q0) - .short L(SSE4Q3) -L(SSE0Q0) - .short L(SSE5Q3) -L(SSE0Q0) - .short L(SSE6Q3) -L(SSE0Q0) - .short L(SSE7Q3) -L(SSE0Q0) - - .short L(SSE8Q3) -L(SSE0Q0) - .short L(SSE9Q3) -L(SSE0Q0) - .short L(SSE10Q3)-L(SSE0Q0) - .short L(SSE11Q3)-L(SSE0Q0) - .short L(SSE12Q3)-L(SSE0Q0) - .short L(SSE13Q3)-L(SSE0Q0) - .short L(SSE14Q3)-L(SSE0Q0) - .short L(SSE15Q3)-L(SSE0Q0) - - .short L(SSE0Q4) -L(SSE0Q0) - .short L(SSE1Q4) -L(SSE0Q0) - .short L(SSE2Q4) -L(SSE0Q0) - .short L(SSE3Q4) -L(SSE0Q0) - .short L(SSE4Q4) -L(SSE0Q0) - .short L(SSE5Q4) -L(SSE0Q0) - .short L(SSE6Q4) -L(SSE0Q0) - .short L(SSE7Q4) -L(SSE0Q0) - - .short L(SSE8Q4) -L(SSE0Q0) - .short L(SSE9Q4) -L(SSE0Q0) - .short L(SSE10Q4)-L(SSE0Q0) - .short L(SSE11Q4)-L(SSE0Q0) - .short L(SSE12Q4)-L(SSE0Q0) - .short L(SSE13Q4)-L(SSE0Q0) - .short L(SSE14Q4)-L(SSE0Q0) - .short L(SSE15Q4)-L(SSE0Q0) - - .short L(SSE0Q5) -L(SSE0Q0) - .short L(SSE1Q5) -L(SSE0Q0) - .short L(SSE2Q5) -L(SSE0Q0) - .short L(SSE3Q5) -L(SSE0Q0) - .short L(SSE4Q5) -L(SSE0Q0) - .short L(SSE5Q5) -L(SSE0Q0) - .short L(SSE6Q5) -L(SSE0Q0) - .short L(SSE7Q5) -L(SSE0Q0) - - .short L(SSE8Q5) -L(SSE0Q0) - .short L(SSE9Q5) -L(SSE0Q0) - .short L(SSE10Q5)-L(SSE0Q0) - .short L(SSE11Q5)-L(SSE0Q0) - .short L(SSE12Q5)-L(SSE0Q0) - .short L(SSE13Q5)-L(SSE0Q0) - .short L(SSE14Q5)-L(SSE0Q0) - .short L(SSE15Q5)-L(SSE0Q0) - - .short L(SSE0Q6) -L(SSE0Q0) - .short L(SSE1Q6) -L(SSE0Q0) - .short L(SSE2Q6) -L(SSE0Q0) - .short L(SSE3Q6) -L(SSE0Q0) - .short L(SSE4Q6) -L(SSE0Q0) - .short L(SSE5Q6) -L(SSE0Q0) - .short L(SSE6Q6) -L(SSE0Q0) - .short L(SSE7Q6) -L(SSE0Q0) - - .short L(SSE8Q6) -L(SSE0Q0) - .short L(SSE9Q6) -L(SSE0Q0) - .short L(SSE10Q6)-L(SSE0Q0) - .short L(SSE11Q6)-L(SSE0Q0) - .short L(SSE12Q6)-L(SSE0Q0) - .short L(SSE13Q6)-L(SSE0Q0) - .short L(SSE14Q6)-L(SSE0Q0) - .short L(SSE15Q6)-L(SSE0Q0) - - .short L(SSE0Q7) -L(SSE0Q0) - .short L(SSE1Q7) -L(SSE0Q0) - .short L(SSE2Q7) -L(SSE0Q0) - .short L(SSE3Q7) -L(SSE0Q0) - .short L(SSE4Q7) -L(SSE0Q0) - .short L(SSE5Q7) -L(SSE0Q0) - .short L(SSE6Q7) -L(SSE0Q0) - .short L(SSE7Q7) -L(SSE0Q0) - - .short L(SSE8Q7) -L(SSE0Q0) - .short L(SSE9Q7) -L(SSE0Q0) - .short L(SSE10Q7)-L(SSE0Q0) - .short L(SSE11Q7)-L(SSE0Q0) - .short L(SSE12Q7)-L(SSE0Q0) - .short L(SSE13Q7)-L(SSE0Q0) - .short L(SSE14Q7)-L(SSE0Q0) - .short L(SSE15Q7)-L(SSE0Q0) - - .short L(SSE0Q8) -L(SSE0Q0) - .short L(SSE1Q8) -L(SSE0Q0) - .short L(SSE2Q8) -L(SSE0Q0) - .short L(SSE3Q8) -L(SSE0Q0) - .short L(SSE4Q8) -L(SSE0Q0) - .short L(SSE5Q8) -L(SSE0Q0) - .short L(SSE6Q8) -L(SSE0Q0) - .short L(SSE7Q8) -L(SSE0Q0) - - .short L(SSE8Q8) -L(SSE0Q0) - .short L(SSE9Q8) -L(SSE0Q0) - .short L(SSE10Q8)-L(SSE0Q0) - .short L(SSE11Q8)-L(SSE0Q0) - .short L(SSE12Q8)-L(SSE0Q0) - .short L(SSE13Q8)-L(SSE0Q0) - .short L(SSE14Q8)-L(SSE0Q0) - .short L(SSE15Q8)-L(SSE0Q0) - - .short L(SSE0Q9) -L(SSE0Q0) - .short L(SSE1Q9) -L(SSE0Q0) - .short L(SSE2Q9) -L(SSE0Q0) - .short L(SSE3Q9) -L(SSE0Q0) - .short L(SSE4Q9) -L(SSE0Q0) - .short L(SSE5Q9) -L(SSE0Q0) - .short L(SSE6Q9) -L(SSE0Q0) - .short L(SSE7Q9) -L(SSE0Q0) - - .short L(SSE8Q9) -L(SSE0Q0) - .short L(SSE9Q9) -L(SSE0Q0) - .short L(SSE10Q9)-L(SSE0Q0) - .short L(SSE11Q9)-L(SSE0Q0) - .short L(SSE12Q9)-L(SSE0Q0) - .short L(SSE13Q9)-L(SSE0Q0) - .short L(SSE14Q9)-L(SSE0Q0) - .short L(SSE15Q9)-L(SSE0Q0) - - .short L(SSE0QA) -L(SSE0Q0) - .short L(SSE1QA) -L(SSE0Q0) - .short L(SSE2QA) -L(SSE0Q0) - .short L(SSE3QA) -L(SSE0Q0) - .short L(SSE4QA) -L(SSE0Q0) - .short L(SSE5QA) -L(SSE0Q0) - .short L(SSE6QA) -L(SSE0Q0) - .short L(SSE7QA) -L(SSE0Q0) - - .short L(SSE8QA) -L(SSE0Q0) - .short L(SSE9QA) -L(SSE0Q0) - .short L(SSE10QA)-L(SSE0Q0) - .short L(SSE11QA)-L(SSE0Q0) - .short L(SSE12QA)-L(SSE0Q0) - .short L(SSE13QA)-L(SSE0Q0) - .short L(SSE14QA)-L(SSE0Q0) - .short L(SSE15QA)-L(SSE0Q0) - - .short L(SSE0QB) -L(SSE0Q0) - .short L(SSE1QB) -L(SSE0Q0) - .short L(SSE2QB) -L(SSE0Q0) - .short L(SSE3QB) -L(SSE0Q0) - .short L(SSE4QB) -L(SSE0Q0) - .short L(SSE5QB) -L(SSE0Q0) - .short L(SSE6QB) -L(SSE0Q0) - .short L(SSE7QB) -L(SSE0Q0) - - .short L(SSE8QB) -L(SSE0Q0) - .short L(SSE9QB) -L(SSE0Q0) - .short L(SSE10QB)-L(SSE0Q0) - .short L(SSE11QB)-L(SSE0Q0) - .short L(SSE12QB)-L(SSE0Q0) - .short L(SSE13QB)-L(SSE0Q0) - .short L(SSE14QB)-L(SSE0Q0) - .short L(SSE15QB)-L(SSE0Q0) -# endif - .popsection -#endif /* !defined USE_MULTIARCH || defined USE_SSE2 */ - - .balign 16 -#ifndef USE_MULTIARCH -L(aligned_now): - - cmpl $0x1,__x86_preferred_memory_instruction(%rip) - jg L(SSE_pre) -#endif /* USE_MULTIARCH */ - -L(8byte_move_try): - cmpq __STOS_LOWER_BOUNDARY,%r8 - jae L(8byte_stos_try) - - .balign 16 -L(8byte_move): - movq %r8,%rcx - shrq $7,%rcx - jz L(8byte_move_skip) - - .p2align 4 - -L(8byte_move_loop): - decq %rcx - - movq %rdx, (%rdi) - movq %rdx, 8 (%rdi) - movq %rdx, 16 (%rdi) - movq %rdx, 24 (%rdi) - movq %rdx, 32 (%rdi) - movq %rdx, 40 (%rdi) - movq %rdx, 48 (%rdi) - movq %rdx, 56 (%rdi) - movq %rdx, 64 (%rdi) - movq %rdx, 72 (%rdi) - movq %rdx, 80 (%rdi) - movq %rdx, 88 (%rdi) - movq %rdx, 96 (%rdi) - movq %rdx, 104 (%rdi) - movq %rdx, 112 (%rdi) - movq %rdx, 120 (%rdi) - - leaq 128 (%rdi),%rdi - - jnz L(8byte_move_loop) - -L(8byte_move_skip): - andl $127,%r8d - lea (%rdi,%r8,1),%rdi - -#ifndef PIC - lea L(setPxQx)(%rip),%r11 - jmpq *(%r11,%r8,8) # old scheme remained for nonPIC -#else - lea L(Got0)(%rip),%r11 - lea L(setPxQx)(%rip),%rcx - movswq (%rcx,%r8,2),%rcx - lea (%rcx,%r11,1),%r11 - jmpq *%r11 -#endif - - .balign 16 -L(8byte_stos_try): - mov __x86_shared_cache_size(%rip),%r9d // ck largest cache size - cmpq %r8,%r9 // calculate the lesser of remaining - cmovaq %r8,%r9 // bytes and largest cache size - jbe L(8byte_stos) - -L(8byte_move_reuse_try): - cmp __STOS_UPPER_BOUNDARY,%r8 - jae L(8byte_move) - - .balign 16 -L(8byte_stos): - movq %r9,%rcx - andq $-8,%r9 - - shrq $3,%rcx - jz L(8byte_stos_skip) - - xchgq %rax,%rdx +ENTRY (memset) + movd %esi, %xmm8 + movq %rdi, %rax + punpcklbw %xmm8, %xmm8 + punpcklwd %xmm8, %xmm8 + pshufd $0, %xmm8, %xmm8 +L(entry_from_bzero): + cmpq $64, %rdx + ja L(loop_start) + cmpq $16, %rdx + jbe L(less_16_bytes) + cmpq $32, %rdx + movdqu %xmm8, (%rdi) + movdqu %xmm8, -16(%rdi,%rdx) + ja L(between_32_64_bytes) +L(return): rep - stosq - - xchgq %rax,%rdx - -L(8byte_stos_skip): - subq %r9,%r8 - ja L(8byte_nt_move) - - andl $7,%r8d - lea (%rdi,%r8,1),%rdi -#ifndef PIC - lea L(setPxQx)(%rip),%r11 - jmpq *(%r11,%r8,8) # old scheme remained for nonPIC -#else - lea L(Got0)(%rip),%r11 - lea L(setPxQx)(%rip),%rcx - movswq (%rcx,%r8,2),%rcx - lea (%rcx,%r11,1),%r11 - jmpq *%r11 -#endif - - .balign 16 -L(8byte_nt_move): - movq %r8,%rcx - shrq $7,%rcx - jz L(8byte_nt_move_skip) - - .balign 16 -L(8byte_nt_move_loop): - decq %rcx - - movntiq %rdx, (%rdi) - movntiq %rdx, 8 (%rdi) - movntiq %rdx, 16 (%rdi) - movntiq %rdx, 24 (%rdi) - movntiq %rdx, 32 (%rdi) - movntiq %rdx, 40 (%rdi) - movntiq %rdx, 48 (%rdi) - movntiq %rdx, 56 (%rdi) - movntiq %rdx, 64 (%rdi) - movntiq %rdx, 72 (%rdi) - movntiq %rdx, 80 (%rdi) - movntiq %rdx, 88 (%rdi) - movntiq %rdx, 96 (%rdi) - movntiq %rdx, 104 (%rdi) - movntiq %rdx, 112 (%rdi) - movntiq %rdx, 120 (%rdi) - - leaq 128 (%rdi),%rdi - - jnz L(8byte_nt_move_loop) - - sfence - -L(8byte_nt_move_skip): - andl $127,%r8d - - lea (%rdi,%r8,1),%rdi -#ifndef PIC - lea L(setPxQx)(%rip),%r11 - jmpq *(%r11,%r8,8) # old scheme remained for nonPIC -#else - lea L(Got0)(%rip),%r11 - lea L(setPxQx)(%rip),%rcx - movswq (%rcx,%r8,2),%rcx - lea (%rcx,%r11,1),%r11 - jmpq *%r11 -#endif + ret + ALIGN (4) +L(between_32_64_bytes): + movdqu %xmm8, 16(%rdi) + movdqu %xmm8, -32(%rdi,%rdx) + ret + ALIGN (4) +L(loop_start): + leaq 64(%rdi), %rcx + movdqu %xmm8, (%rdi) + andq $-64, %rcx + movdqu %xmm8, -16(%rdi,%rdx) + movdqu %xmm8, 16(%rdi) + movdqu %xmm8, -32(%rdi,%rdx) + movdqu %xmm8, 32(%rdi) + movdqu %xmm8, -48(%rdi,%rdx) + movdqu %xmm8, 48(%rdi) + movdqu %xmm8, -64(%rdi,%rdx) + addq %rdi, %rdx + andq $-64, %rdx + cmpq %rdx, %rcx + je L(return) + ALIGN (4) +L(loop): + movdqa %xmm8, (%rcx) + movdqa %xmm8, 16(%rcx) + movdqa %xmm8, 32(%rcx) + movdqa %xmm8, 48(%rcx) + addq $64, %rcx + cmpq %rcx, %rdx + jne L(loop) + rep + ret +L(less_16_bytes): + movq %xmm8, %rcx + testb $24, %dl + jne L(between8_16bytes) + testb $4, %dl + jne L(between4_7bytes) + testb $1, %dl + je L(odd_byte) + movb %cl, (%rdi) +L(odd_byte): + testb $2, %dl + je L(return) + movw %cx, -2(%rax,%rdx) + ret +L(between4_7bytes): + movl %ecx, (%rdi) + movl %ecx, -4(%rdi,%rdx) + ret +L(between8_16bytes): + movq %rcx, (%rdi) + movq %rcx, -8(%rdi,%rdx) + ret END (memset) libc_hidden_builtin_def (memset) diff --git a/libc/sysdeps/x86_64/multiarch/Makefile b/libc/sysdeps/x86_64/multiarch/Makefile index 86787ee6e..203d16eed 100644 --- a/libc/sysdeps/x86_64/multiarch/Makefile +++ b/libc/sysdeps/x86_64/multiarch/Makefile @@ -7,7 +7,7 @@ endif ifeq ($(subdir),string) sysdep_routines += strncat-c stpncpy-c strncpy-c strcmp-ssse3 strncmp-ssse3 \ - strend-sse4 memcmp-sse4 memcpy-ssse3 mempcpy-ssse3 \ + strend-sse4 memcmp-sse4 memcpy-ssse3 memcpy-sse2-unaligned mempcpy-ssse3 \ memmove-ssse3 memcpy-ssse3-back mempcpy-ssse3-back \ memmove-ssse3-back strcasestr-nonascii strcasecmp_l-ssse3 \ strncase_l-ssse3 strcat-ssse3 strncat-ssse3\ diff --git a/libc/sysdeps/x86_64/multiarch/ifunc-impl-list.c b/libc/sysdeps/x86_64/multiarch/ifunc-impl-list.c index 05315fdd7..28d35793c 100644 --- a/libc/sysdeps/x86_64/multiarch/ifunc-impl-list.c +++ b/libc/sysdeps/x86_64/multiarch/ifunc-impl-list.c @@ -227,6 +227,7 @@ __libc_ifunc_impl_list (const char *name, struct libc_ifunc_impl *array, IFUNC_IMPL_ADD (array, i, memcpy, HAS_SSSE3, __memcpy_ssse3_back) IFUNC_IMPL_ADD (array, i, memcpy, HAS_SSSE3, __memcpy_ssse3) + IFUNC_IMPL_ADD (array, i, memcpy, 1, __memcpy_sse2_unaligned) IFUNC_IMPL_ADD (array, i, memcpy, 1, __memcpy_sse2)) /* Support sysdeps/x86_64/multiarch/mempcpy_chk.S. */ diff --git a/libc/sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S b/libc/sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S new file mode 100644 index 000000000..efdfea238 --- /dev/null +++ b/libc/sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S @@ -0,0 +1,175 @@ +/* memcpy with unaliged loads + Copyright (C) 2013 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <http://www.gnu.org/licenses/>. */ + +#include <sysdep.h> + +#include "asm-syntax.h" + +#ifndef ALIGN +# define ALIGN(n) .p2align n +#endif + + +ENTRY(__memcpy_sse2_unaligned) + movq %rsi, %rax + leaq (%rdx,%rdx), %rcx + subq %rdi, %rax + subq %rdx, %rax + cmpq %rcx, %rax + jb L(overlapping) + cmpq $16, %rdx + jbe L(less_16) + movdqu (%rsi), %xmm8 + cmpq $32, %rdx + movdqu %xmm8, (%rdi) + movdqu -16(%rsi,%rdx), %xmm8 + movdqu %xmm8, -16(%rdi,%rdx) + ja .L31 +L(return): + movq %rdi, %rax + ret + .p2align 4,,10 + ALIGN(4) +.L31: + movdqu 16(%rsi), %xmm8 + cmpq $64, %rdx + movdqu %xmm8, 16(%rdi) + movdqu -32(%rsi,%rdx), %xmm8 + movdqu %xmm8, -32(%rdi,%rdx) + jbe L(return) + movdqu 32(%rsi), %xmm8 + cmpq $128, %rdx + movdqu %xmm8, 32(%rdi) + movdqu -48(%rsi,%rdx), %xmm8 + movdqu %xmm8, -48(%rdi,%rdx) + movdqu 48(%rsi), %xmm8 + movdqu %xmm8, 48(%rdi) + movdqu -64(%rsi,%rdx), %xmm8 + movdqu %xmm8, -64(%rdi,%rdx) + jbe L(return) + leaq 64(%rdi), %rcx + addq %rdi, %rdx + andq $-64, %rdx + andq $-64, %rcx + movq %rcx, %rax + subq %rdi, %rax + addq %rax, %rsi + cmpq %rdx, %rcx + je L(return) + movq %rsi, %r10 + subq %rcx, %r10 + leaq 16(%r10), %r9 + leaq 32(%r10), %r8 + leaq 48(%r10), %rax + .p2align 4,,10 + ALIGN(4) +L(loop): + movdqu (%rcx,%r10), %xmm8 + movdqa %xmm8, (%rcx) + movdqu (%rcx,%r9), %xmm8 + movdqa %xmm8, 16(%rcx) + movdqu (%rcx,%r8), %xmm8 + movdqa %xmm8, 32(%rcx) + movdqu (%rcx,%rax), %xmm8 + movdqa %xmm8, 48(%rcx) + addq $64, %rcx + cmpq %rcx, %rdx + jne L(loop) + jmp L(return) +L(overlapping): + cmpq %rsi, %rdi + jae .L3 + testq %rdx, %rdx + .p2align 4,,5 + je L(return) + movq %rdx, %r9 + leaq 16(%rsi), %rcx + leaq 16(%rdi), %r8 + shrq $4, %r9 + movq %r9, %rax + salq $4, %rax + cmpq %rcx, %rdi + setae %cl + cmpq %r8, %rsi + setae %r8b + orl %r8d, %ecx + cmpq $15, %rdx + seta %r8b + testb %r8b, %cl + je .L16 + testq %rax, %rax + je .L16 + xorl %ecx, %ecx + xorl %r8d, %r8d +.L7: + movdqu (%rsi,%rcx), %xmm8 + addq $1, %r8 + movdqu %xmm8, (%rdi,%rcx) + addq $16, %rcx + cmpq %r8, %r9 + ja .L7 + cmpq %rax, %rdx + je L(return) +.L21: + movzbl (%rsi,%rax), %ecx + movb %cl, (%rdi,%rax) + addq $1, %rax + cmpq %rax, %rdx + ja .L21 + jmp L(return) +L(less_16): + testb $24, %dl + jne L(between_9_16) + testb $4, %dl + .p2align 4,,5 + jne L(between_5_8) + testq %rdx, %rdx + .p2align 4,,2 + je L(return) + movzbl (%rsi), %eax + testb $2, %dl + movb %al, (%rdi) + je L(return) + movzwl -2(%rsi,%rdx), %eax + movw %ax, -2(%rdi,%rdx) + jmp L(return) +.L3: + leaq -1(%rdx), %rax + .p2align 4,,10 + ALIGN(4) +.L11: + movzbl (%rsi,%rax), %edx + movb %dl, (%rdi,%rax) + subq $1, %rax + jmp .L11 +L(between_9_16): + movq (%rsi), %rax + movq %rax, (%rdi) + movq -8(%rsi,%rdx), %rax + movq %rax, -8(%rdi,%rdx) + jmp L(return) +.L16: + xorl %eax, %eax + jmp .L21 +L(between_5_8): + movl (%rsi), %eax + movl %eax, (%rdi) + movl -4(%rsi,%rdx), %eax + movl %eax, -4(%rdi,%rdx) + jmp L(return) +END(__memcpy_sse2_unaligned) diff --git a/libc/sysdeps/x86_64/multiarch/memcpy.S b/libc/sysdeps/x86_64/multiarch/memcpy.S index b452f5304..a1e503137 100644 --- a/libc/sysdeps/x86_64/multiarch/memcpy.S +++ b/libc/sysdeps/x86_64/multiarch/memcpy.S @@ -33,13 +33,14 @@ ENTRY(__new_memcpy) jne 1f call __init_cpu_features 1: leaq __memcpy_sse2(%rip), %rax - testl $bit_SSSE3, __cpu_features+CPUID_OFFSET+index_SSSE3(%rip) - jz 2f - leaq __memcpy_ssse3(%rip), %rax - testl $bit_Fast_Copy_Backward, __cpu_features+FEATURE_OFFSET+index_Fast_Copy_Backward(%rip) - jz 2f - leaq __memcpy_ssse3_back(%rip), %rax -2: ret + testl $bit_Slow_BSF, __cpu_features+FEATURE_OFFSET+index_Slow_BSF(%rip) + jnz 2f + leaq __memcpy_sse2_unaligned(%rip), %rax + ret +2: testl $bit_SSSE3, __cpu_features+CPUID_OFFSET+index_SSSE3(%rip) + jz 3f + leaq __memcpy_ssse3(%rip), %rax +3: ret END(__new_memcpy) # undef ENTRY |