static void
check_nans (void)
{
mpfr_t x, y;
mpfr_init2 (x, 123L);
mpfr_init2 (y, 123L);
mpfr_set_nan (x);
test_sin (y, x, MPFR_RNDN);
if (! mpfr_nan_p (y))
{
printf ("Error: sin(NaN) != NaN\n");
exit (1);
}
mpfr_set_inf (x, 1);
test_sin (y, x, MPFR_RNDN);
if (! mpfr_nan_p (y))
{
printf ("Error: sin(Inf) != NaN\n");
exit (1);
}
mpfr_set_inf (x, -1);
test_sin (y, x, MPFR_RNDN);
if (! mpfr_nan_p (y))
{
printf ("Error: sin(-Inf) != NaN\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
}
int main(int argc, char *argv[])
{
ULONG res = 0;
MathIeeeSingTransBase = (BaseType *)OpenLibrary("mathieeesingtrans.library", 34);
if(MathIeeeSingTransBase) {
PutStr("ok!\n");
test_const();
test_acos();
test_asin();
test_atan();
test_cos();
test_cosh();
test_exp();
test_fieee();
test_log();
test_log10();
test_pow();
test_sin();
test_sincos();
test_sinh();
test_sqrt();
test_tan();
test_tanh();
test_tieee();
CloseLibrary((struct Library *)MathIeeeSingTransBase);
} else {
PutStr("No mathieeesingtrans.library!\n");
res = 1;
}
return res;
}
int main ( int argc, char *argv[] )
/******************************************************************************/
/*
Purpose:
MAIN is the main program for C_INTRINSICS.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
16 April 2011
Author:
John Burkardt
*/
{
timestamp ( );
printf ( "\n" );
printf ( "C_INTRINSICS:\n" );
printf ( " Test the C intrinsic library.\n" );
test_abs ( );
test_acos ( );
test_asin ( );
test_atan ( );
test_atan2 ( );
test_ceil ( );
test_cos ( );
test_cosh ( );
test_exp ( );
test_fabs ( );
test_floor ( );
test_fmod ( );
test_frexp ( );
test_ldexp ( );
test_log ( );
test_log10 ( );
test_modf ( );
test_pow ( );
test_sin ( );
test_sinh ( );
test_sqrt ( );
test_tan ( );
test_tanh ( );
/*
Terminate.
*/
printf ( "\n" );
printf ( "C_INTRINSICS:\n" );
printf ( " Normal end of execution.\n" );
printf ( "\n" );
timestamp ( );
return 0;
}
static void
check53b (const char *xs, const char *sin_xs, mpfr_rnd_t rnd_mode)
{
mpfr_t xx, s;
mpfr_init2 (xx, 53);
mpfr_init2 (s, 53);
mpfr_set_str (xx, xs, 2, MPFR_RNDN); /* should be exact */
test_sin (s, xx, rnd_mode);
if (mpfr_cmp_str (s, sin_xs, 2, MPFR_RNDN))
{
printf ("mpfr_sin failed in rounding mode %s for\n x = %s\n",
mpfr_print_rnd_mode (rnd_mode), xs);
printf (" got ");
mpfr_out_str (stdout, 2, 0, s, MPFR_RNDN);
printf ("\nexpected %s\n", sin_xs);
exit (1);
}
mpfr_clear (xx);
mpfr_clear (s);
}
static void
check53 (const char *xs, const char *sin_xs, mpfr_rnd_t rnd_mode)
{
mpfr_t xx, s;
mpfr_init2 (xx, 53);
mpfr_init2 (s, 53);
mpfr_set_str1 (xx, xs); /* should be exact */
test_sin (s, xx, rnd_mode);
if (mpfr_cmp_str1 (s, sin_xs))
{
printf ("mpfr_sin failed for x=%s, rnd=%s\n",
xs, mpfr_print_rnd_mode (rnd_mode));
printf ("mpfr_sin gives sin(x)=");
mpfr_out_str (stdout, 10, 0, s, MPFR_RNDN);
printf (", expected %s\n", sin_xs);
exit (1);
}
mpfr_clear (xx);
mpfr_clear (s);
}
static void
test_sign (void)
{
mpfr_t pid, piu, x, y;
int p, k;
mpfr_init2 (pid, 4096);
mpfr_const_pi (pid, MPFR_RNDD);
mpfr_init2 (piu, 4096);
mpfr_const_pi (piu, MPFR_RNDU);
mpfr_init (x);
mpfr_init2 (y, 2);
for (p = 8; p <= 128; p++)
for (k = 2; k <= 6; k += 2)
{
mpfr_set_prec (x, p);
mpfr_mul_ui (x, pid, k, MPFR_RNDD);
test_sin (y, x, MPFR_RNDN);
if (MPFR_SIGN(y) > 0)
{
printf ("Error in test_sign for sin(%dpi-epsilon), prec = %d"
" for argument.\nResult should have been negative.\n",
k, p);
exit (1);
}
mpfr_mul_ui (x, piu, k, MPFR_RNDU);
test_sin (y, x, MPFR_RNDN);
if (MPFR_SIGN(y) < 0)
{
printf ("Error in test_sign for sin(%dpi+epsilon), prec = %d"
" for argument.\nResult should have been positive.\n",
k, p);
exit (1);
}
}
/* worst case on 53 bits */
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str (x, "6134899525417045", 10, MPFR_RNDN);
test_sin (y, x, MPFR_RNDN);
mpfr_set_str_binary (x, "11011010111101011110111100010101010101110000000001011E-106");
MPFR_ASSERTN(mpfr_cmp (x, y) == 0);
/* Bug on Special cases */
mpfr_set_str_binary (x, "0.100011011010111101E-32");
test_sin (y, x, MPFR_RNDN);
if (mpfr_cmp_str (y, "0.10001101101011110100000000000000000000000000000000000E-32", 2, MPFR_RNDN))
{
printf("sin special 97 error:\nx=");
mpfr_dump (x); printf("y=");
mpfr_dump (y);
exit (1);
}
mpfr_set_prec (x, 53);
mpfr_set_prec (y, 53);
mpfr_set_str_binary (x, "1.1001001000011111101101010100010001000010110100010011");
mpfr_set_str_binary (y, "1.1111111111111111111111111111111111111111111111111111e-1");
test_sin (x, x, MPFR_RNDZ);
MPFR_ASSERTN(mpfr_cmp (x, y) == 0);
mpfr_clear (pid);
mpfr_clear (piu);
mpfr_clear (x);
mpfr_clear (y);
}
int
main (int argc, char *argv[])
{
mpfr_t x, c, s, c2, s2;
tests_start_mpfr ();
check_regression ();
check_nans ();
/* worst case from PhD thesis of Vincent Lefe`vre: x=8980155785351021/2^54 */
check53 ("4.984987858808754279e-1", "4.781075595393330379e-1", MPFR_RNDN);
check53 ("4.984987858808754279e-1", "4.781075595393329824e-1", MPFR_RNDD);
check53 ("4.984987858808754279e-1", "4.781075595393329824e-1", MPFR_RNDZ);
check53 ("4.984987858808754279e-1", "4.781075595393330379e-1", MPFR_RNDU);
check53 ("1.00031274099908640274", "8.416399183372403892e-1", MPFR_RNDN);
check53 ("1.00229256850978698523", "8.427074524447979442e-1", MPFR_RNDZ);
check53 ("1.00288304857059840103", "8.430252033025980029e-1", MPFR_RNDZ);
check53 ("1.00591265847407274059", "8.446508805292128885e-1", MPFR_RNDN);
/* Other worst cases showing a bug introduced on 2005-01-29 in rev 3248 */
check53b ("1.0111001111010111010111111000010011010001110001111011e-21",
"1.0111001111010111010111111000010011010001101001110001e-21",
MPFR_RNDU);
check53b ("1.1011101111111010000001010111000010000111100100101101",
"1.1111100100101100001111100000110011110011010001010101e-1",
MPFR_RNDU);
mpfr_init2 (x, 2);
mpfr_set_str (x, "0.5", 10, MPFR_RNDN);
test_sin (x, x, MPFR_RNDD);
if (mpfr_cmp_ui_2exp (x, 3, -3)) /* x != 0.375 = 3/8 */
{
printf ("mpfr_sin(0.5, MPFR_RNDD) failed with precision=2\n");
exit (1);
}
/* bug found by Kevin Ryde */
mpfr_const_pi (x, MPFR_RNDN);
mpfr_mul_ui (x, x, 3L, MPFR_RNDN);
mpfr_div_ui (x, x, 2L, MPFR_RNDN);
test_sin (x, x, MPFR_RNDN);
if (mpfr_cmp_ui (x, 0) >= 0)
{
printf ("Error: wrong sign for sin(3*Pi/2)\n");
exit (1);
}
/* Can fail on an assert */
mpfr_set_prec (x, 53);
mpfr_set_str (x, "77291789194529019661184401408", 10, MPFR_RNDN);
mpfr_init2 (c, 4); mpfr_init2 (s, 42);
mpfr_init2 (c2, 4); mpfr_init2 (s2, 42);
test_sin (s, x, MPFR_RNDN);
mpfr_cos (c, x, MPFR_RNDN);
mpfr_sin_cos (s2, c2, x, MPFR_RNDN);
if (mpfr_cmp (c2, c))
{
printf("cos differs for x=77291789194529019661184401408");
exit (1);
}
if (mpfr_cmp (s2, s))
{
printf("sin differs for x=77291789194529019661184401408");
exit (1);
}
mpfr_set_str_binary (x, "1.1001001000011111101101010100010001000010110100010011");
test_sin (x, x, MPFR_RNDZ);
if (mpfr_cmp_str (x, "1.1111111111111111111111111111111111111111111111111111e-1", 2, MPFR_RNDN))
{
printf ("Error for x= 1.1001001000011111101101010100010001000010110100010011\nGot ");
mpfr_dump (x);
exit (1);
}
mpfr_set_prec (s, 9);
mpfr_set_prec (x, 190);
mpfr_const_pi (x, MPFR_RNDN);
mpfr_sin (s, x, MPFR_RNDZ);
if (mpfr_cmp_str (s, "0.100000101e-196", 2, MPFR_RNDN))
{
printf ("Error for x ~= pi\n");
mpfr_dump (s);
exit (1);
}
mpfr_clear (s2);
mpfr_clear (c2);
mpfr_clear (s);
mpfr_clear (c);
mpfr_clear (x);
test_generic (2, 100, 15);
test_generic (MPFR_SINCOS_THRESHOLD-1, MPFR_SINCOS_THRESHOLD+1, 2);
test_sign ();
check_tiny ();
data_check ("data/sin", mpfr_sin, "mpfr_sin");
bad_cases (mpfr_sin, mpfr_asin, "mpfr_sin", 256, -40, 0, 4, 128, 800, 50);
tests_end_mpfr ();
return 0;
}
int main()
{
test_acos();
test_asin();
test_atan();
test_atan2();
test_ceil();
test_cos();
test_cosh();
test_exp();
test_fabs();
test_floor();
test_fmod();
test_frexp();
test_ldexp();
test_log();
test_log10();
test_modf();
test_pow();
test_sin();
test_sinh();
test_sqrt();
test_tan();
test_tanh();
test_signbit();
test_fpclassify();
test_isfinite();
test_isinf();
test_isnan();
test_isnormal();
test_isgreater();
test_isgreaterequal();
test_isless();
test_islessequal();
test_islessgreater();
test_isunordered();
test_acosh();
test_asinh();
test_atanh();
test_cbrt();
test_copysign();
test_erf();
test_erfc();
test_exp2();
test_expm1();
test_fdim();
test_fma();
test_fmax();
test_fmin();
test_hypot();
test_ilogb();
test_lgamma();
test_llrint();
test_llround();
test_log1p();
test_log2();
test_logb();
test_lrint();
test_lround();
test_nan();
test_nearbyint();
test_nextafter();
test_nexttoward();
test_remainder();
test_remquo();
test_rint();
test_round();
test_scalbln();
test_scalbn();
test_tgamma();
test_trunc();
}
void
selftest(void)
{
// for handling "errout"
if (setjmp(jbuf))
return;
#if SELFTEST
test_low_level();
test_multiply();
test_scan();
test_power();
test_factor_number();
test_test();
test_tensor();
test_bake();
test(__FILE__, s, sizeof (s) / sizeof (char *)); // "s" is in selftest.h
test_abs();
test_adj();
test_arg();
test_besselj();
test_bessely();
test_ceiling();
test_choose();
test_circexp();
test_clock();
test_cofactor();
test_condense();
test_contract();
test_defint();
test_denominator();
test_derivative();
test_dirac();
test_erf();
test_erfc();
test_expand();
test_expcos();
test_expsin();
test_factorpoly();
test_float();
test_floor();
test_gamma();
test_gcd();
test_imag();
test_inner();
test_lcm();
test_log();
test_mag();
test_mod();
test_nroots();
test_numerator();
test_outer();
test_polar();
test_quotient();
test_rationalize();
test_real();
test_rect();
test_sgn();
test_taylor();
test_transpose();
test_zero();
test_hermite();
test_laguerre();
test_legendre();
test_binomial();
test_divisors();
test_coeff();
test_sin();
test_cos();
test_tan();
test_sinh();
test_cosh();
test_tanh();
test_arcsin();
test_arcsinh();
test_arccos();
test_arccosh();
test_arctan();
test_arctanh();
test_index();
test_isprime();
test_integral();
test_simplify();
test_roots();
test_eigen();
#endif
mini_test();
logout("OK, all tests passed.\n");
}
static void test_all_sin() {
test_sin(zero, zero, "0");
test_sin(epsilon, epsilon, "epsilon");
test_sin(cent, dec64_new(9999833334166665, -18), "0.01");
test_sin(one, dec64_new(8414709848078965, -16), "1");
test_sin(half_pi, one, "pi/2");
test_sin(two, dec64_new(9092974268256817, -16), "2");
test_sin(e, dec64_new(4107812905029087, -16), "e");
test_sin(three, dec64_new(14112000805986722, -17), "3");
test_sin(pi, zero, "pi");
test_sin(four, dec64_new(-7568024953079283, -16), "4");
test_sin(five, dec64_new(-9589242746631385, -16), "5");
test_sin(ten, dec64_new(-5440211108893698, -16), "10");
test_sin(dec64_new(-1, 0), dec64_new(-8414709848078965, -16), "-1");
}
