/// @brief Calculate A1
///
/// Calculate the probability of making a move divided by the
/// probability of its reverse, that is:
/// \f[a_1=\frac{move[i]}{\sum\limits_{i}move[i]}\f]
///
/// @param move The type of move
/// @return \f$a_1=\frac{move[i]}{\sum\limits_{i}move[i]}\f$
auto CalculateA1(const move_type move) const noexcept
{
auto total_moves = this->TotalMoves();
auto this_move = attempted_moves_[to_integral(move)];
// Set precision for initialization and assignment functions
mpfr_set_default_prec(PRECISION);
// Initialize for MPFR
mpfr_t r1, r2, a1;
mpfr_inits2(PRECISION, r1, r2, a1, nullptr);
mpfr_init_set_ui(r1, this_move, MPFR_RNDD); // r1 = this_move
mpfr_init_set_ui(r2, total_moves, MPFR_RNDD); // r2 = total_moves
// The result
mpfr_div(a1, r1, r2, MPFR_RNDD); // a1 = r1/r2
// std::cout << "A1 is " << mpfr_out_str(stdout, 10, 0, a1, MPFR_RNDD)
// Convert mpfr_t total to Gmpzf result by using Gmpzf(double d)
// Gmpzf result = Gmpzf(mpfr_get_d(a1, MPFR_RNDD));
// MP_Float result = MP_Float(mpfr_get_ld(a1, MPFR_RNDD));
auto result = mpfr_get_d(a1, MPFR_RNDD);
// Free memory
mpfr_clears(r1, r2, a1, nullptr);
#ifndef NDEBUG
std::cout << "TotalMoves() = " << total_moves << "\n";
std::cout << "A1 is " << result << "\n";
#endif
return result;
} // CalculateA1()
void mpfr_bisect_nRoot(mpfr_t R, mpfr_t N, mpfr_t T, unsigned int n)
{
if(mpfr_cmp_ui(N, 0) < 0)
{
fprintf(stderr, "The value to square root must be non-negative\n");
exit(-1);
}
if(mpfr_cmp_ui(T, 0) < 0)
{
fprintf(stderr, "The tolerance must be non-negative\n");
exit(-1);
}
assert(n >= 2);
mpfr_t a, b, x, f, d, fab;
//Set a == 0
mpfr_init_set_ui(a, 0, MPFR_RNDN);
//Set b = max{1, N}
mpfr_init(b);
mpfr_max(b, MPFR_ONE, N, MPFR_RNDN);
//Set x = (a + b)/2
mpfr_init(x);
mpfr_add(x, a, b, MPFR_RNDN);
mpfr_mul(x, x, MPFR_HALF, MPFR_RNDN);
//Set f = x^2 - N
mpfr_init(f);
mpfr_init(fab);
mpfr_pow_ui(f, x, n, MPFR_RNDN);
mpfr_sub(f, f, N, MPFR_RNDN);
mpfr_abs(fab, f, MPFR_RNDN);
//Set d = b - a
mpfr_init(d);
mpfr_sub(d, b, a, MPFR_RNDN);
while(mpfr_cmp(fab, T) > 0 && mpfr_cmp(d, T) > 0)
{
//Update the bounds, a and b
if(mpfr_cmp_ui(f, 0) < 0)
mpfr_set(a, x, MPFR_RNDN);
else
mpfr_set(b, x, MPFR_RNDN);
//Update x
mpfr_add(x, a, b, MPFR_RNDN);
mpfr_mul(x, x, MPFR_HALF, MPFR_RNDN);
//Update f
mpfr_pow_ui(f, x, n, MPFR_RNDN);
mpfr_sub(f, f, N, MPFR_RNDN);
mpfr_abs(fab, f, MPFR_RNDN);
}
mpfr_set(R, x, MPFR_RNDN);
}
int
main (void)
{
mpfr_t x, y, z, u;
int inexact;
mpfr_exp_t emax;
tests_start_mpfr ();
/* check prototypes of mpfr_init_set_* */
inexact = mpfr_init_set_si (x, -1, MPFR_RNDN);
inexact = mpfr_init_set (y, x, MPFR_RNDN);
inexact = mpfr_init_set_ui (z, 1, MPFR_RNDN);
inexact = mpfr_init_set_d (u, 1.0, MPFR_RNDN);
emax = mpfr_get_emax ();
set_emax (0);
mpfr_set_prec (x, 3);
mpfr_set_str_binary (x, "0.111");
mpfr_set_prec (y, 2);
mpfr_set (y, x, MPFR_RNDU);
if (!(MPFR_IS_INF (y) && MPFR_SIGN (y) > 0))
{
printf ("Error for y=x=0.111 with px=3, py=2 and emax=0\nx=");
mpfr_dump (x);
printf ("y=");
mpfr_dump (y);
exit (1);
}
set_emax (emax);
mpfr_set_prec (y, 11);
mpfr_set_str_binary (y, "0.11111111100E-8");
mpfr_set_prec (x, 2);
mpfr_set (x, y, MPFR_RNDN);
mpfr_set_str_binary (y, "1.0E-8");
if (mpfr_cmp (x, y))
{
printf ("Error for y=0.11111111100E-8, prec=2, rnd=MPFR_RNDN\n");
exit (1);
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (u);
check_ternary_value ();
check_special ();
check_neg_special ();
test_generic (2, 1000, 10);
tests_end_mpfr ();
return 0;
}
int
main (void)
{
mp_prec_t p, q;
mpfr_t x, y, z, u;
mp_rnd_t rnd;
int inexact, cmp;
/* check prototypes of mpfr_init_set_* */
inexact = mpfr_init_set_si (x, -1, GMP_RNDN);
inexact = mpfr_init_set (y, x, GMP_RNDN);
inexact = mpfr_init_set_ui (z, 1, GMP_RNDN);
inexact = mpfr_init_set_d (u, 1.0, GMP_RNDN);
mpfr_set_prec (y, 11);
mpfr_set_str_raw (y, "0.11111111100E-8");
mpfr_set_prec (x, 2);
mpfr_set (x, y, GMP_RNDN);
mpfr_set_str_raw (y, "1.0E-8");
if (mpfr_cmp (x, y))
{
fprintf (stderr, "Error for y=0.11111111100E-8, prec=2, rnd=GMP_RNDN\n");
exit (1);
}
for (p=2; p<500; p++)
{
mpfr_set_prec (x, p);
mpfr_random (x);
if (LONG_RAND () % 2)
mpfr_neg (x, x, GMP_RNDN);
for (q=2; q<2*p; q++)
{
mpfr_set_prec (y, q);
for (rnd=0; rnd<4; rnd++)
{
inexact = mpfr_set (y, x, rnd);
cmp = mpfr_cmp (y, x);
if (((inexact == 0) && (cmp != 0)) ||
((inexact > 0) && (cmp <= 0)) ||
((inexact < 0) && (cmp >= 0)))
{
fprintf (stderr, "Wrong inexact flag in mpfr_set: expected %d, got %d\n", cmp, inexact);
exit (1);
}
}
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (u);
return 0;
}
void mpfr_taylor_cos_bounded(mpfr_t R, mpfr_t x, unsigned int N)
{
assert(mpfr_cmp_ui(x, 0) >= 0 && mpfr_cmp(x, MPFR_HALF_PI) <= 0);
mpfr_t t, x_2;
mpfr_init_set_ui(R, 1, MPFR_RNDN);
mpfr_init_set_ui(t, 1, MPFR_RNDN);
mpfr_init(x_2);
mpfr_mul(x_2, x, x, MPFR_RNDN);
for(int n = 1; n < N; n++)
{
mpfr_div_ui(t, t, (2*n-1)*(2*(n++)), MPFR_RNDN);
mpfr_mul(t, t, x_2, MPFR_RNDN);
mpfr_sub(R, R, t, MPFR_RNDN);
mpfr_div_ui(t, t, (2*n-1)*(2*n), MPFR_RNDN);
mpfr_mul(t, t, x_2, MPFR_RNDN);
mpfr_add(R, R, t, MPFR_RNDN);
}
}
void mpfr_taylor_exp(mpfr_t R, mpfr_t x, mpz_t n)
{
assert(mpz_cmp_ui(n, 0) >= 0);
mpfr_t t;
mpz_t k;
mpfr_init_set_ui(t, 1, MPFR_RNDN);
mpfr_set_ui(R, 1, MPFR_RNDN);
for(mpz_init_set_ui(k, 1); mpz_cmp(k, n) < 0; mpz_add_ui(k, k, 1))
{
mpfr_mul(t, t, x, MPFR_RNDN);
mpfr_div_z(t, t, k, MPFR_RNDN);
mpfr_add(R, R, t, MPFR_RNDN);
}
}
int
lunar_phase( mpfr_t *result, mpfr_t *moment ) {
mpfr_t sl, ll, fullangle;
mpfr_init(sl);
mpfr_init(ll);
mpfr_init_set_ui(fullangle, 360, GMP_RNDN);
solar_longitude( &sl, moment );
lunar_longitude( &ll, moment );
mpfr_sub(*result, ll, sl, GMP_RNDN );
dt_astro_mod(result, result, &fullangle);
mpfr_clear(sl);
mpfr_clear(ll);
mpfr_clear(fullangle);
return 1;
}
int
main (void)
{
mpfr_t x;
intmax_t j;
tests_start_mpfr ();
mpfr_init_set_ui (x, 1, MPFR_RNDN);
j = mpfr_get_uj (x, MPFR_RNDN);
mpfr_clear (x);
if (j != 1)
{
#ifdef MPFR_PRINTF_MAXLM
printf ("Error: got %" MPFR_PRINTF_MAXLM "d instead of 1.\n", j);
#else
printf ("Error: did not get 1.\n");
#endif
exit (1);
}
tests_end_mpfr ();
return 0;
}
int
main (int argc, char *argv[])
{
int type = 'z';
int base = 0;
mp_size_t prec = 64;
int obase, opt, i, ret;
while ((opt = getopt (argc, argv, "b:fp:qrz")) != EOF)
{
switch (opt) {
case 'f':
case 'q':
case 'r':
case 'z':
type = opt;
break;
case 'b':
base = atoi (optarg);
break;
case 'p':
prec = atoi (optarg);
break;
case '?':
default:
abort ();
}
}
obase = (base == 0 ? 10 : base);
if (optind >= argc)
{
printf ("Usage: %s [-z] [-q] [-f] [-r] [-p prec] [-b base] expression...\n", argv[0]);
exit (1);
}
switch (type) {
case 'z':
default:
{
mpz_t res, foo, bar;
mpz_init (res);
mpz_init_set_ui (foo, 55L);
mpz_init_set_ui (bar, 99L);
for (i = optind; i < argc; i++)
TRY (mpz_expr, mpz_out_str (stdout, obase, res), argv[i]);
mpz_clear (res);
mpz_clear (foo);
mpz_clear (bar);
}
break;
case 'q':
{
mpq_t res, foo, bar;
mpq_init (res);
mpq_init (foo);
mpq_init (bar);
mpq_set_ui (foo, 55L, 1);
mpq_set_ui (bar, 99L, 1);
for (i = optind; i < argc; i++)
TRY (mpq_expr, mpq_out_str (stdout, obase, res), argv[i]);
mpq_clear (res);
mpq_clear (foo);
mpq_clear (bar);
}
break;
case 'f':
{
mpf_t res, foo, bar;
mpf_init2 (res, prec);
mpf_init_set_ui (foo, 55L);
mpf_init_set_ui (bar, 99L);
for (i = optind; i < argc; i++)
TRY (mpf_expr, mpf_out_str (stdout, obase, 0, res), argv[i]);
mpf_clear (res);
mpf_clear (foo);
mpf_clear (bar);
}
break;
case 'r':
#if HAVE_MPFR
{
mpfr_t res, foo, bar;
mpfr_init2 (res, prec);
mpfr_init_set_ui (foo, 55L, GMP_RNDZ);
mpfr_init_set_ui (bar, 99L, GMP_RNDZ);
for (i = optind; i < argc; i++)
TRY (mpfr_expr,
mpfr_out_str (stdout, obase, 0, res, GMP_RNDZ),
argv[i]);
mpfr_clear (res);
mpfr_clear (foo);
mpfr_clear (bar);
}
#else
printf ("mpfr not compiled in\n");
exit (1);
#endif
break;
}
return 0;
}
int main (int argc, char *argv[]){
mpfr_t *lambda, *kappa;
char f_out_name[BUFSIZ];
int d,iters,n, k, nk,nf,na,nb;
double *lambdas, *kappas, *f,*a,*b;
param_file_type param[Nparam] =
{{"d:" , "%d", &d, NULL, sizeof(int)},
{"iter:" , "%d", &iters, NULL, sizeof(int)},
{"lambda:", "DATA_FILE", &lambdas, &n , sizeof(double)},
{"kappa:", "DATA_FILE", &kappas, &nk , sizeof(double)}, /*psi*/
{"h:", "DATA_FILE", &f, &nf , sizeof(double)}, /*odf*/
{"a:", "DATA_FILE", &a, &na , sizeof(double)}, /*pdf a*/
{"bc:", "DATA_FILE", &b, &nb , sizeof(double)}, /*pdf sqrt(b^2 + c^2)*/
{"res1:","%s ", &f_out_name,NULL, 0}};
FILE *f_param;
FILE *f_out;
if (argc<2) {
printf("Error! Missing parameter - parameter_file.\n");
printf("%s\n",argv[0]);
abort();
}
/* read parameter file */
f_param = check_fopen(argv[1],"r");
if (read_param_file(f_param,param,Nparam,argc==2)<Nparam){
/*printf("Some parameters not found!");*/
/*abort();*/
}
fclose(f_param);
/* precission & delta */
init_prec(d);
long int prec = d;
if (nk>0) { /* kappas given*/
mpfr_t C;
kappa = (mpfr_t*) malloc (nk*sizeof(mpfr_t));
for(k=0;k<nk;k++){
mpfr_init2(kappa[k],prec);
mpfr_init_set_d(kappa[k], kappas[k],prec);
}
mhyper(C, kappa, nk);
/* gmp_printf("C: %.*Fe \n ", 20, C); */
if (nf>0) /* eval odf values*/
{
eval_exp_Ah(C,f,nf);
f_out = check_fopen(f_out_name,"wb");
fwrite(f,sizeof(double),nf,f_out);
fclose(f_out);
}
if ( na > 0) {/* eval pdf values*/
/* testing BesselI[0,a]
mpfr_t in, out;
for(k=0;k<na;k++){
mpfr_init2(in, prec);
mpfr_set_d(in, a[k],prec);
mpfr_init2(out, prec);
mpfr_i0(out, in, prec);
mpfr_printf ("%.1028RNf\ndd", out);
a[k] = mpfr_get_d(out,prec);
}
f_out = check_fopen(f_out_name,"wb");
fwrite(a,sizeof(double),na,f_out);
fclose(f_out);
*/
eval_exp_besseli(a,b,C,na);
f_out = check_fopen(f_out_name,"wb");
fwrite(a,sizeof(double),na,f_out);
fclose(f_out);
}
if (nf == 0 && na == 0) { /* only return constant */
double CC = mpfr_get_d(C,prec);
f_out = check_fopen(f_out_name,"wb");
fwrite(&CC,sizeof(double),1,f_out);
fclose(f_out);
}
} else { /* solve kappas */
/* copy input variables */
lambda = (mpfr_t*) malloc (n*sizeof(mpfr_t));
kappa = (mpfr_t*) malloc (n*sizeof(mpfr_t));
for(k=0;k<n;k++){
mpfr_init_set_ui(kappa[k],0,prec);
mpfr_init_set_d(lambda[k],lambdas[k],prec);
}
if(iters>0){
/* check input */
mpfr_t tmp;
mpfr_init(tmp);
mpfr_set_d(tmp,0,prec);
for(k=0;k<n;k++){
mpfr_add(tmp,tmp,lambda[k],prec);
}
mpfr_ui_sub(tmp,1,tmp,prec);
mpfr_div_ui(tmp,tmp,n,prec);
for(k=0;k<n;k++){
mpfr_add(lambda[k],lambda[k],tmp,prec);
}
mpfr_init2(tmp,prec);
for(k=0;k<n;k++){
mpfr_add(tmp,tmp,lambda[k],prec);
}
mpfr_init2(tmp,prec);
if( mpfr_cmp(lambda[min_N(lambda,n)],tmp) < 0 ){
printf("not well formed! sum should be exactly 1 and no lambda negativ");
exit(0);
}
/* solve the problem */
newton(iters,kappa, lambda, n);
} else {
guessinitial(kappa, lambda, n);
}
for(k=0;k<n;k++){
lambdas[k] = mpfr_get_d(kappa[k],GMP_RNDN); /* something wents wront in matlab for 473.66316276431799;*/
/* % bug: lambda= [0.97 0.01 0.001];*/
}
f_out = check_fopen(f_out_name,"wb");
fwrite(lambdas,sizeof(double),n,f_out);
fclose(f_out);
free_N(lambda,n);
free_N(kappa,n);
}
return EXIT_SUCCESS;
}
int
nth_new_moon( mpfr_t *result, int n_int ) {
mpfr_t n, k, C, approx, E, solar_anomaly, lunar_anomaly, moon_argument, omega, extra, correction, additional;
#if(0)
PerlIO_printf(PerlIO_stderr(), "nth_new_moon = %d\n", n_int );
#endif
if ( dt_astro_global_cache.cache_size > n_int ) {
mpfr_t *cached = dt_astro_global_cache.cache[n_int];
if (cached != NULL) {
#if(0)
PerlIO_printf(PerlIO_stderr(), "Cache HIT for %d\n", n_int);
#endif
mpfr_set( *result, *cached, GMP_RNDN );
return 1;
}
}
mpfr_init_set_ui( n, n_int, GMP_RNDN );
/* k = n - 24724 */
mpfr_init_set(k, n, GMP_RNDN);
mpfr_sub_ui(k, k, 24724, GMP_RNDN );
/* c = k / 1236.85 */
mpfr_init_set(C, k, GMP_RNDN );
mpfr_div_d(C, C, 1236.85, GMP_RNDN);
{
mpfr_t a, b, c, d, e;
mpfr_init(approx);
mpfr_init_set_d(a, 730125.59765, GMP_RNDN );
mpfr_init_set_d(b, MEAN_SYNODIC_MONTH * 1236.85, GMP_RNDN );
mpfr_init_set_d(c, 0.0001337, GMP_RNDN );
mpfr_init_set_d(d, -0.000000150, GMP_RNDN );
mpfr_init_set_d(e, 0.00000000073, GMP_RNDN );
polynomial( &approx, &C, 5, &a, &b, &c, &d, &e );
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpfr_clear(d);
mpfr_clear(e);
#ifdef ANNOYING_DEBUG
#if (ANNOYING_DEBUG)
mpfr_fprintf(stderr,
"approx = %.10RNf\n", approx);
#endif
#endif
}
{
mpfr_t a, b, c;
mpfr_init(E);
mpfr_init_set_ui(a, 1, GMP_RNDN);
mpfr_init_set_d(b, -0.002516, GMP_RNDN );
mpfr_init_set_d(c, -0.0000074, GMP_RNDN );
polynomial( &E, &C, 3, &a, &b, &c );
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
}
{
mpfr_t a, b, c, d;
mpfr_init(solar_anomaly);
mpfr_init_set_d(a, 2.5534, GMP_RNDN);
mpfr_init_set_d(b, 1236.85, GMP_RNDN);
mpfr_mul_d(b, b, 29.10535669, GMP_RNDN);
mpfr_init_set_d(c, -0.0000218, GMP_RNDN );
mpfr_init_set_d(d, -0.00000011, GMP_RNDN );
polynomial( &solar_anomaly, &C, 4, &a, &b, &c, &d);
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpfr_clear(d);
}
{
mpfr_t a, b, c, d, e;
mpfr_init(lunar_anomaly);
mpfr_init_set_d(a, 201.5643, GMP_RNDN);
mpfr_init_set_d(b, 385.81693528 * 1236.85, GMP_RNDN);
mpfr_init_set_d(c, 0.0107438, GMP_RNDN);
mpfr_init_set_d(d, 0.00001239, GMP_RNDN);
mpfr_init_set_d(e, -0.000000058, GMP_RNDN);
polynomial( &lunar_anomaly, &C, 5, &a, &b, &c, &d, &e);
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpfr_clear(d);
mpfr_clear(e);
}
{
mpfr_t a, b, c, d, e;
mpfr_init(moon_argument);
mpfr_init_set_d(a, 160.7108, GMP_RNDN);
mpfr_init_set_d(b, 390.67050274 * 1236.85, GMP_RNDN);
mpfr_init_set_d(c, -0.0016431, GMP_RNDN);
mpfr_init_set_d(d, -0.00000227, GMP_RNDN);
mpfr_init_set_d(e, 0.000000011, GMP_RNDN);
polynomial( &moon_argument, &C, 5, &a, &b, &c, &d, &e);
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpfr_clear(d);
mpfr_clear(e);
}
{
mpfr_t a, b, c, d;
mpfr_init(omega);
mpfr_init_set_d(a, 124.7746, GMP_RNDN);
mpfr_init_set_d(b, -1.56375580 * 1236.85, GMP_RNDN);
mpfr_init_set_d(c, 0.0020691, GMP_RNDN);
mpfr_init_set_d(d, 0.00000215, GMP_RNDN);
polynomial( &omega, &C, 4, &a, &b, &c, &d);
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpfr_clear(d);
}
{
mpfr_t a, b, c;
mpfr_init(extra);
mpfr_init_set_d(a, 299.77, GMP_RNDN);
mpfr_init_set_d(b, 132.8475848, GMP_RNDN);
mpfr_init_set_d(c, -0.009173, GMP_RNDN);
polynomial(&extra, &c, 3, &a, &b, &c);
dt_astro_sin(&extra, &extra);
mpfr_mul_d(extra, extra, 0.000325, GMP_RNDN);
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
}
mpfr_init(correction);
dt_astro_sin(&correction, &omega);
mpfr_mul_d(correction, correction, -0.00017, GMP_RNDN);
{
int i;
for( i = 0; i < NTH_NEW_MOON_CORRECTION_ARGS_SIZE; i++ ) {
mpfr_t a, v, w, x, y, z;
mpfr_init_set_d(v, NTH_NEW_MOON_CORRECTION_ARGS[i][0], GMP_RNDN);
mpfr_init_set_d(w, NTH_NEW_MOON_CORRECTION_ARGS[i][1], GMP_RNDN);
mpfr_init_set_d(x, NTH_NEW_MOON_CORRECTION_ARGS[i][2], GMP_RNDN);
mpfr_init_set_d(y, NTH_NEW_MOON_CORRECTION_ARGS[i][3], GMP_RNDN);
mpfr_init_set_d(z, NTH_NEW_MOON_CORRECTION_ARGS[i][4], GMP_RNDN);
mpfr_mul(x, x, solar_anomaly, GMP_RNDN);
mpfr_mul(y, y, lunar_anomaly, GMP_RNDN);
mpfr_mul(z, z, moon_argument, GMP_RNDN);
mpfr_add(x, x, y, GMP_RNDN);
mpfr_add(x, x, z, GMP_RNDN);
dt_astro_sin(&x, &x);
mpfr_init(a);
mpfr_pow(a, E, w, GMP_RNDN);
mpfr_mul(a, a, v, GMP_RNDN);
mpfr_mul(a, a, x, GMP_RNDN);
mpfr_add( correction, correction, a, GMP_RNDN );
mpfr_clear(a);
mpfr_clear(v);
mpfr_clear(w);
mpfr_clear(x);
mpfr_clear(y);
mpfr_clear(z);
}
}
{
int z;
mpfr_init_set_ui(additional, 0, GMP_RNDN);
for (z = 0; z < NTH_NEW_MOON_ADDITIONAL_ARGS_SIZE; z++) {
mpfr_t i, j, l;
mpfr_init_set_d(i, NTH_NEW_MOON_ADDITIONAL_ARGS[z][0], GMP_RNDN);
mpfr_init_set_d(j, NTH_NEW_MOON_ADDITIONAL_ARGS[z][1], GMP_RNDN);
mpfr_init_set_d(l, NTH_NEW_MOON_ADDITIONAL_ARGS[z][2], GMP_RNDN);
mpfr_mul(j, j, k, GMP_RNDN);
mpfr_add(j, j, i, GMP_RNDN);
dt_astro_sin(&j, &j);
mpfr_mul(l, l, j, GMP_RNDN);
mpfr_add(additional, additional, l, GMP_RNDN);
mpfr_clear(i);
mpfr_clear(j);
mpfr_clear(l);
}
}
#ifdef ANNOYING_DEBUG
#if (ANNOYING_DEBUG)
mpfr_fprintf(stderr,
"correction = %.10RNf\nextra = %.10RNf\nadditional = %.10RNf\n", correction, extra, additional );
#endif
#endif
mpfr_set(*result, approx, GMP_RNDN);
mpfr_add(*result, *result, correction, GMP_RNDN);
mpfr_add(*result, *result, extra, GMP_RNDN);
mpfr_add(*result, *result, additional, GMP_RNDN);
adjust_lunar_phase_to_zero( result );
mpfr_clear(n);
mpfr_clear(k);
mpfr_clear(C);
mpfr_clear(approx);
mpfr_clear(E);
mpfr_clear(solar_anomaly);
mpfr_clear(lunar_anomaly);
mpfr_clear(moon_argument);
mpfr_clear(omega);
mpfr_clear(extra);
mpfr_clear(correction);
mpfr_clear(additional);
if (dt_astro_global_cache.cache_size == 0) {
dt_astro_global_cache.cache_size = 200000;
Newxz( dt_astro_global_cache.cache, dt_astro_global_cache.cache_size, mpfr_t * );
}
int
lunar_longitude( mpfr_t *result, mpfr_t *moment ) {
mpfr_t C, mean_moon, elongation, solar_anomaly, lunar_anomaly, moon_node, E, correction, venus, jupiter, flat_earth, N, fullangle;
mpfr_init(C);
julian_centuries( &C, moment );
{
mpfr_t a, b, c, d, e;
mpfr_init(mean_moon);
mpfr_init_set_d(a, 218.316591, GMP_RNDN);
mpfr_init_set_d(b, 481267.88134236, GMP_RNDN);
mpfr_init_set_d(c, -0.0013268, GMP_RNDN);
mpfr_init_set_ui(d, 1, GMP_RNDN);
mpfr_div_ui(d, d, 538841, GMP_RNDN);
mpfr_init_set_si(e, -1, GMP_RNDN);
mpfr_div_ui(e, e, 65194000, GMP_RNDN);
polynomial( &mean_moon, &C, 5, &a, &b, &c, &d, &e );
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpfr_clear(d);
mpfr_clear(e);
}
{
mpfr_t a, b, c, d, e;
mpfr_init(elongation);
mpfr_init_set_d(a, 297.8502042, GMP_RNDN);
mpfr_init_set_d(b, 445267.1115168, GMP_RNDN);
mpfr_init_set_d(c, -0.00163, GMP_RNDN);
mpfr_init_set_ui(d, 1, GMP_RNDN);
mpfr_div_ui(d, d, 545868, GMP_RNDN);
mpfr_init_set_si(e, -1, GMP_RNDN);
mpfr_div_ui(e, e, 113065000, GMP_RNDN);
polynomial( &elongation, &C, 5, &a, &b, &c, &d, &e );
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpfr_clear(d);
mpfr_clear(e);
}
{
mpfr_t a, b, c, d;
mpfr_init(solar_anomaly);
mpfr_init_set_d(a, 357.5291092, GMP_RNDN);
mpfr_init_set_d(b, 35999.0502909, GMP_RNDN);
mpfr_init_set_d(c, -0.0001536, GMP_RNDN);
mpfr_init_set_ui(d, 1, GMP_RNDN);
mpfr_div_ui(d, d, 24490000, GMP_RNDN);
polynomial( &solar_anomaly, &C, 4, &a, &b, &c, &d );
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpfr_clear(d);
}
{
mpfr_t a, b, c, d, e;
mpfr_init(lunar_anomaly);
mpfr_init_set_d(a, 134.9634114, GMP_RNDN);
mpfr_init_set_d(b, 477198.8676313, GMP_RNDN);
mpfr_init_set_d(c, 0.0008997, GMP_RNDN);
mpfr_init_set_ui(d, 1, GMP_RNDN);
mpfr_div_ui(d, d, 69699, GMP_RNDN);
mpfr_init_set_si(e, -1, GMP_RNDN);
mpfr_div_ui(e, e, 14712000, GMP_RNDN);
polynomial( &lunar_anomaly, &C, 5, &a, &b, &c, &d, &e);
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpfr_clear(d);
mpfr_clear(e);
}
{
mpfr_t a, b, c, d, e;
mpfr_init(moon_node);
mpfr_init_set_d(a, 93.2720993, GMP_RNDN);
mpfr_init_set_d(b, 483202.0175273, GMP_RNDN);
mpfr_init_set_d(c, -0.0034029, GMP_RNDN);
mpfr_init_set_si(d, -1, GMP_RNDN);
mpfr_div_ui(d, d, 3526000, GMP_RNDN);
mpfr_init_set_ui(e, 1, GMP_RNDN);
mpfr_div_ui(e, e, 863310000, GMP_RNDN);
polynomial(&moon_node, &C, 5, &a, &b, &c, &d, &e);
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
mpfr_clear(d);
mpfr_clear(e);
}
{
mpfr_t a, b, c;
mpfr_init(E);
mpfr_init_set_ui(a, 1, GMP_RNDN);
mpfr_init_set_d(b, -0.002516, GMP_RNDN);
mpfr_init_set_d(c, -0.0000074, GMP_RNDN);
polynomial( &E, &C, 3, &a, &b, &c );
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(c);
}
{
int i;
mpfr_t fugly;
mpfr_init_set_ui(fugly, 0, GMP_RNDN);
for(i = 0; i < LUNAR_LONGITUDE_ARGS_SIZE; i++) {
mpfr_t a, b, v, w, x, y, z;
mpfr_init_set_d( v, LUNAR_LONGITUDE_ARGS[i][0], GMP_RNDN );
mpfr_init_set_d( w, LUNAR_LONGITUDE_ARGS[i][1], GMP_RNDN );
mpfr_init_set_d( x, LUNAR_LONGITUDE_ARGS[i][2], GMP_RNDN );
mpfr_init_set_d( y, LUNAR_LONGITUDE_ARGS[i][3], GMP_RNDN );
mpfr_init_set_d( z, LUNAR_LONGITUDE_ARGS[i][4], GMP_RNDN );
mpfr_init(b);
mpfr_pow(b, E, x, GMP_RNDN);
mpfr_mul(w, w, elongation, GMP_RNDN);
mpfr_mul(x, x, solar_anomaly, GMP_RNDN);
mpfr_mul(y, y, lunar_anomaly, GMP_RNDN);
mpfr_mul(z, z, moon_node, GMP_RNDN);
mpfr_init_set(a, w, GMP_RNDN);
mpfr_add(a, a, x, GMP_RNDN);
mpfr_add(a, a, y, GMP_RNDN);
mpfr_add(a, a, z, GMP_RNDN);
dt_astro_sin(&a, &a);
mpfr_mul(a, a, v, GMP_RNDN);
mpfr_mul(a, a, b, GMP_RNDN);
mpfr_add(fugly, fugly, a, GMP_RNDN);
mpfr_clear(a);
mpfr_clear(b);
mpfr_clear(v);
mpfr_clear(w);
mpfr_clear(x);
mpfr_clear(y);
mpfr_clear(z);
}
mpfr_init_set_d( correction, 0.000001, GMP_RNDN );
mpfr_mul( correction, correction, fugly, GMP_RNDN);
mpfr_clear(fugly);
}
{
mpfr_t a, b;
mpfr_init(venus);
mpfr_init_set_d(a, 119.75, GMP_RNDN);
mpfr_init_set(b, C, GMP_RNDN);
mpfr_mul_d(b, b, 131.849, GMP_RNDN);
mpfr_add(a, a, b, GMP_RNDN);
dt_astro_sin(&a, &a);
mpfr_mul_d(venus, a, 0.003957, GMP_RNDN );
mpfr_clear(a);
mpfr_clear(b);
}
{
mpfr_t a, b;
mpfr_init(jupiter);
mpfr_init_set_d(a, 53.09, GMP_RNDN);
mpfr_init_set(b, C, GMP_RNDN);
mpfr_mul_d(b, b, 479264.29, GMP_RNDN);
mpfr_add(a, a, b, GMP_RNDN);
dt_astro_sin(&a, &a);
mpfr_mul_d(jupiter, a, 0.000318, GMP_RNDN );
mpfr_clear(a);
mpfr_clear(b);
}
{
mpfr_t a;
mpfr_init(flat_earth);
mpfr_init_set(a, mean_moon, GMP_RNDN);
mpfr_sub(a, a, moon_node, GMP_RNDN);
dt_astro_sin(&a, &a);
mpfr_mul_d(flat_earth, a, 0.001962, GMP_RNDN);
mpfr_clear(a);
}
mpfr_set(*result, mean_moon, GMP_RNDN);
mpfr_add(*result, *result, correction, GMP_RNDN);
mpfr_add(*result, *result, venus, GMP_RNDN);
mpfr_add(*result, *result, jupiter, GMP_RNDN);
mpfr_add(*result, *result, flat_earth, GMP_RNDN);
#ifdef ANNOYING_DEBUG
#if (ANNOYING_DEBUG)
mpfr_fprintf(stderr,
"mean_moon = %.10RNf\ncorrection = %.10RNf\nvenus = %.10RNf\njupiter = %.10RNf\nflat_earth = %.10RNf\n",
mean_moon,
correction,
venus,
jupiter,
flat_earth);
#endif
#endif
mpfr_init(N);
nutation(&N, moment);
mpfr_add(*result, *result, N, GMP_RNDN);
mpfr_init_set_ui(fullangle, 360, GMP_RNDN);
#ifdef ANNOYING_DEBUG
#if (ANNOYING_DEBUG)
mpfr_fprintf(stderr, "lunar = mod(%.10RNf) = ", *result );
#endif
#endif
dt_astro_mod(result, result, &fullangle);
#ifdef ANNOYING_DEBUG
#if (ANNOYING_DEBUG)
mpfr_fprintf(stderr, "%.10RNf\n", *result );
#endif
#endif
mpfr_clear(C);
mpfr_clear(mean_moon);
mpfr_clear(elongation);
mpfr_clear(solar_anomaly);
mpfr_clear(lunar_anomaly);
mpfr_clear(moon_node);
mpfr_clear(E);
mpfr_clear(correction);
mpfr_clear(venus);
mpfr_clear(jupiter);
mpfr_clear(flat_earth);
mpfr_clear(N);
mpfr_clear(fullangle);
return 1;
}
void inline mpfr_digits_to_tolerance(unsigned int D, mpfr_t T)
{
mpfr_init_set_ui(T, 10, MPFR_RNDN);
mpfr_pow_ui(T, T, D, MPFR_RNDN);
mpfr_ui_div(T, 1, T, MPFR_RNDN);
}
int
main (void)
{
mp_prec_t p, q;
mpfr_t x, y, z, u;
int rnd;
int inexact, cmp;
mp_exp_t emax;
tests_start_mpfr ();
/* check prototypes of mpfr_init_set_* */
inexact = mpfr_init_set_si (x, -1, GMP_RNDN);
inexact = mpfr_init_set (y, x, GMP_RNDN);
inexact = mpfr_init_set_ui (z, 1, GMP_RNDN);
inexact = mpfr_init_set_d (u, 1.0, GMP_RNDN);
mpfr_set_nan (x);
(mpfr_set) (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_nan_p (y));
mpfr_set_inf (x, 1);
mpfr_set (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && mpfr_sgn (y) > 0);
mpfr_set_inf (x, -1);
mpfr_set (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_inf_p (y) && mpfr_sgn (y) < 0);
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_set (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_POS(y));
mpfr_set_ui (x, 0, GMP_RNDN);
mpfr_neg (x, x, GMP_RNDN);
mpfr_set (y, x, GMP_RNDN);
MPFR_ASSERTN(mpfr_cmp_ui (y, 0) == 0 && MPFR_IS_NEG(y));
emax = mpfr_get_emax ();
set_emax (0);
mpfr_set_prec (x, 3);
mpfr_set_str_binary (x, "0.111");
mpfr_set_prec (y, 2);
mpfr_set (y, x, GMP_RNDU);
if (!(MPFR_IS_INF (y) && MPFR_SIGN (y) > 0))
{
printf ("Error for y=x=0.111 with px=3, py=2 and emax=0\nx=");
mpfr_dump (x);
printf ("y=");
mpfr_dump (y);
exit (1);
}
MPFR_ASSERTN (MPFR_IS_INF (y) && MPFR_SIGN (y) > 0);
set_emax (emax);
mpfr_set_prec (y, 11);
mpfr_set_str_binary (y, "0.11111111100E-8");
mpfr_set_prec (x, 2);
mpfr_set (x, y, GMP_RNDN);
mpfr_set_str_binary (y, "1.0E-8");
if (mpfr_cmp (x, y))
{
printf ("Error for y=0.11111111100E-8, prec=2, rnd=GMP_RNDN\n");
exit (1);
}
for (p=2; p<500; p++)
{
mpfr_set_prec (x, p);
mpfr_random (x);
if (randlimb () % 2)
mpfr_neg (x, x, GMP_RNDN);
for (q=2; q<2*p; q++)
{
mpfr_set_prec (y, q);
for (rnd = 0; rnd < GMP_RND_MAX; rnd++)
{
inexact = mpfr_set (y, x, (mp_rnd_t) rnd);
cmp = mpfr_cmp (y, x);
if (((inexact == 0) && (cmp != 0)) ||
((inexact > 0) && (cmp <= 0)) ||
((inexact < 0) && (cmp >= 0)))
{
printf ("Wrong inexact flag in mpfr_set: expected %d,"
" got %d\n", cmp, inexact);
exit (1);
}
}
}
}
mpfr_clear (x);
mpfr_clear (y);
mpfr_clear (z);
mpfr_clear (u);
check_neg_special ();
tests_end_mpfr ();
return 0;
}
void mpfr_bisect_sqrt(mpfr_t R, mpfr_t N, mpfr_t T)
{
if(mpfr_cmp_ui(N, 0) < 0)
{
fprintf(stderr, "The value to square root must be non-negative\n");
exit(-1);
}
if(mpfr_cmp_ui(T, 0) < 0)
{
fprintf(stderr, "The tolerance must be non-negative\n");
exit(-1);
}
mpfr_exp_t e;
mpfr_t a, b, x, f, d, fab, n;
mpfr_init(n);
mpfr_frexp(&e, n, N, MPFR_RNDN);
if(e%2)
{
mpfr_div_ui(n, n, 2, MPFR_RNDN);
e += 1;
}
//Set a == 0
mpfr_init_set_ui(a, 0, MPFR_RNDN);
//Set b == 1
mpfr_init_set_ui(b, 1, MPFR_RNDN);
//Set x = (a + b)/2
mpfr_init(x);
mpfr_add(x, a, b, MPFR_RNDN);
mpfr_mul(x, x, MPFR_HALF, MPFR_RNDN);
//Set f = x^2 - N and fab = |f|
mpfr_init(f);
mpfr_init(fab);
mpfr_mul(f, x, x, MPFR_RNDN);
mpfr_sub(f, f, N, MPFR_RNDN);
mpfr_abs(fab, f, MPFR_RNDN);
//Set d = b - a
mpfr_init(d);
mpfr_sub(d, b, a, MPFR_RNDN);
while(mpfr_cmp(fab, T) > 0 && mpfr_cmp(d, T) > 0)
{
//Update the bounds, a and b
if(mpfr_cmp_ui(f, 0) < 0)
mpfr_set(a, x, MPFR_RNDN);
else
mpfr_set(b, x, MPFR_RNDN);
//Update x
mpfr_add(x, a, b, MPFR_RNDN);
mpfr_mul(x, x, MPFR_HALF, MPFR_RNDN);
//Update f and fab
mpfr_mul(f, x, x, MPFR_RNDN);
mpfr_sub(f, f, n, MPFR_RNDN);
mpfr_abs(fab, f, MPFR_RNDN);
}
printf("beep");
mpfr_mul_2si(R, x, e/2, MPFR_RNDN);
}
