ReactOS Development > Doxygen

fun_mpfr.c

00001 #include "calc.h"
00002 
00003 void apply_int_mask(calc_number_t *r)
00004 {
00005     mpz_t a, mask;
00006 
00007     switch (calc.size) {
00008     case IDC_RADIO_QWORD:
00009         mpz_init_set_str(mask, "FFFFFFFFFFFFFFFF", 16);
00010         break;
00011     case IDC_RADIO_DWORD:
00012         mpz_init_set_str(mask, "00000000FFFFFFFF", 16);
00013         break;
00014     case IDC_RADIO_WORD:
00015         mpz_init_set_str(mask, "000000000000FFFF", 16);
00016         break;
00017     case IDC_RADIO_BYTE:
00018         mpz_init_set_str(mask, "00000000000000FF", 16);
00019         break;
00020     default:
00021         mpz_init_set_si(mask, -1);
00022     }
00023     mpz_init(a);
00024     mpfr_get_z(a, r->mf, MPFR_DEFAULT_RND);
00025     mpz_and(a, a, mask);
00026     mpfr_set_z(r->mf, a, MPFR_DEFAULT_RND);
00027     mpz_clear(a);
00028     mpz_clear(mask);
00029 }
00030 
00031 void validate_rad2angle(calc_number_t *r)
00032 {
00033     mpfr_t mult, divs;
00034 
00035     mpfr_init(mult);
00036     mpfr_init(divs);
00037     switch (calc.degr) {
00038     case IDC_RADIO_DEG:
00039         mpfr_set_ui(mult, 180, MPFR_DEFAULT_RND);
00040         mpfr_const_pi(divs, MPFR_DEFAULT_RND);
00041         break;
00042     case IDC_RADIO_RAD:
00043         mpfr_set_ui(mult, 1, MPFR_DEFAULT_RND);
00044         mpfr_set_ui(divs, 1, MPFR_DEFAULT_RND);
00045         break;
00046     case IDC_RADIO_GRAD:
00047         mpfr_set_ui(mult, 200, MPFR_DEFAULT_RND);
00048         mpfr_const_pi(divs, MPFR_DEFAULT_RND);
00049         break;
00050     }
00051     mpfr_mul(r->mf, r->mf, mult, MPFR_DEFAULT_RND);
00052     mpfr_div(r->mf, r->mf, divs, MPFR_DEFAULT_RND);
00053 
00054     mpfr_clear(mult);
00055     mpfr_clear(divs);
00056 }
00057 
00058 void validate_angle2rad(calc_number_t *r)
00059 {
00060     mpfr_t mult, divs;
00061 
00062     if (!mpfr_number_p(r->mf)) {
00063         calc.is_nan = TRUE;
00064         return;
00065     }
00066     mpfr_init(mult);
00067     mpfr_init(divs);
00068     switch (calc.degr) {
00069     case IDC_RADIO_DEG:
00070         mpfr_const_pi(mult, MPFR_DEFAULT_RND);
00071         mpfr_set_ui(divs, 180, MPFR_DEFAULT_RND);
00072         break;
00073     case IDC_RADIO_RAD:
00074         mpfr_set_ui(mult, 1, MPFR_DEFAULT_RND);
00075         mpfr_set_ui(divs, 1, MPFR_DEFAULT_RND);
00076         break;
00077     case IDC_RADIO_GRAD:
00078         mpfr_const_pi(mult, MPFR_DEFAULT_RND);
00079         mpfr_set_ui(divs, 200, MPFR_DEFAULT_RND);
00080         break;
00081     }
00082     mpfr_mul(r->mf, r->mf, mult, MPFR_DEFAULT_RND);
00083     mpfr_div(r->mf, r->mf, divs, MPFR_DEFAULT_RND);
00084 
00085     mpfr_clear(mult);
00086     mpfr_clear(divs);
00087 }
00088 
00089 static void build_rad_const(
00090     mpfr_t *mp_pi,
00091     mpfr_t *mp_pi_2,
00092     mpfr_t *mp_3_pi_2,
00093     mpfr_t *mp_2_pi)
00094 {
00095     mpfr_init(*mp_pi);
00096     mpfr_init(*mp_pi_2);
00097     mpfr_init(*mp_3_pi_2);
00098     mpfr_init(*mp_2_pi);
00099     mpfr_const_pi(*mp_pi, MPFR_DEFAULT_RND);
00100     mpfr_div_ui(*mp_pi_2, *mp_pi, 2, MPFR_DEFAULT_RND);
00101     mpfr_mul_ui(*mp_3_pi_2, *mp_pi, 3, MPFR_DEFAULT_RND);
00102     mpfr_div_ui(*mp_3_pi_2, *mp_3_pi_2, 2, MPFR_DEFAULT_RND);
00103     mpfr_mul_ui(*mp_2_pi, *mp_pi, 2, MPFR_DEFAULT_RND);
00104 }
00105 
00106 void rpn_sin(calc_number_t *c)
00107 {
00108     mpfr_t mp_pi, mp_pi_2, mp_3_pi_2, mp_2_pi;
00109 
00110     validate_angle2rad(c);
00111     build_rad_const(&mp_pi, &mp_pi_2, &mp_3_pi_2, &mp_2_pi);
00112 
00113     if (rpn_is_zero(c) || !mpfr_cmp(c->mf, mp_pi) || !mpfr_cmp(c->mf, mp_2_pi))
00114         rpn_zero(c);
00115     else
00116     if (!mpfr_cmp(c->mf, mp_3_pi_2))
00117         mpfr_set_si(c->mf, -1, MPFR_DEFAULT_RND);
00118     else
00119     if (!mpfr_cmp(c->mf, mp_pi_2))
00120         mpfr_set_si(c->mf, 1, MPFR_DEFAULT_RND);
00121     else {
00122         mpfr_sin(c->mf, c->mf, MPFR_DEFAULT_RND);
00123         if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00124     }
00125     mpfr_clear(mp_pi);
00126     mpfr_clear(mp_pi_2);
00127     mpfr_clear(mp_3_pi_2);
00128     mpfr_clear(mp_2_pi);
00129 }
00130 void rpn_cos(calc_number_t *c)
00131 {
00132     mpfr_t mp_pi, mp_pi_2, mp_3_pi_2, mp_2_pi;
00133 
00134     validate_angle2rad(c);
00135     build_rad_const(&mp_pi, &mp_pi_2, &mp_3_pi_2, &mp_2_pi);
00136 
00137     if (!mpfr_cmp(c->mf, mp_pi_2) || !mpfr_cmp(c->mf, mp_3_pi_2))
00138         rpn_zero(c);
00139     else
00140     if (!mpfr_cmp(c->mf, mp_pi))
00141         mpfr_set_si(c->mf, -1, MPFR_DEFAULT_RND);
00142     else
00143     if (!mpfr_cmp(c->mf, mp_2_pi))
00144         mpfr_set_si(c->mf, 1, MPFR_DEFAULT_RND);
00145     else {
00146         mpfr_cos(c->mf, c->mf, MPFR_DEFAULT_RND);
00147         if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00148     }
00149     mpfr_clear(mp_pi);
00150     mpfr_clear(mp_pi_2);
00151     mpfr_clear(mp_3_pi_2);
00152     mpfr_clear(mp_2_pi);
00153 }
00154 void rpn_tan(calc_number_t *c)
00155 {
00156     mpfr_t mp_pi, mp_pi_2, mp_3_pi_2, mp_2_pi;
00157 
00158     validate_angle2rad(c);
00159     build_rad_const(&mp_pi, &mp_pi_2, &mp_3_pi_2, &mp_2_pi);
00160 
00161     if (!mpfr_cmp(c->mf, mp_pi_2) || !mpfr_cmp(c->mf, mp_3_pi_2))
00162         calc.is_nan = TRUE;
00163     else
00164     if (!mpfr_cmp(c->mf, mp_pi) || !mpfr_cmp(c->mf, mp_2_pi))
00165         rpn_zero(c);
00166     else {
00167         mpfr_tan(c->mf, c->mf, MPFR_DEFAULT_RND);
00168         if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00169     }
00170     mpfr_clear(mp_pi);
00171     mpfr_clear(mp_pi_2);
00172     mpfr_clear(mp_3_pi_2);
00173     mpfr_clear(mp_2_pi);
00174 }
00175 
00176 void rpn_asin(calc_number_t *c)
00177 {
00178     mpfr_asin(c->mf, c->mf, MPFR_DEFAULT_RND);
00179     validate_rad2angle(c);
00180 }
00181 void rpn_acos(calc_number_t *c)
00182 {
00183     mpfr_acos(c->mf, c->mf, MPFR_DEFAULT_RND);
00184     validate_rad2angle(c);
00185 }
00186 void rpn_atan(calc_number_t *c)
00187 {
00188     mpfr_atan(c->mf, c->mf, MPFR_DEFAULT_RND);
00189     validate_rad2angle(c);
00190 }
00191 
00192 void rpn_sinh(calc_number_t *c)
00193 {
00194     mpfr_sinh(c->mf, c->mf, MPFR_DEFAULT_RND);
00195     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00196 }
00197 void rpn_cosh(calc_number_t *c)
00198 {
00199     mpfr_cosh(c->mf, c->mf, MPFR_DEFAULT_RND);
00200     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00201 }
00202 void rpn_tanh(calc_number_t *c)
00203 {
00204     mpfr_tanh(c->mf, c->mf, MPFR_DEFAULT_RND);
00205     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00206 }
00207 
00208 void rpn_asinh(calc_number_t *c)
00209 {
00210     mpfr_asinh(c->mf, c->mf, MPFR_DEFAULT_RND);
00211     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00212 }
00213 void rpn_acosh(calc_number_t *c)
00214 {
00215     mpfr_acosh(c->mf, c->mf, MPFR_DEFAULT_RND);
00216     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00217 }
00218 void rpn_atanh(calc_number_t *c)
00219 {
00220     mpfr_atanh(c->mf, c->mf, MPFR_DEFAULT_RND);
00221     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00222 }
00223 
00224 void rpn_int(calc_number_t *c)
00225 {
00226     mpfr_trunc(c->mf, c->mf);
00227 }
00228 
00229 void rpn_frac(calc_number_t *c)
00230 {
00231     mpfr_frac(c->mf, c->mf, MPFR_DEFAULT_RND);
00232 }
00233 
00234 void rpn_reci(calc_number_t *c)
00235 {
00236     if (mpfr_sgn(c->mf) == 0)
00237         calc.is_nan = TRUE;
00238     else
00239         mpfr_ui_div(c->mf, 1, c->mf, MPFR_DEFAULT_RND);
00240 }
00241 
00242 void rpn_fact(calc_number_t *c)
00243 {
00244     if (mpfr_sgn(c->mf) < 0) {
00245         calc.is_nan = TRUE;
00246         return;
00247     }
00248 
00249     mpfr_trunc(c->mf, c->mf);
00250     if (mpfr_fits_ulong_p(c->mf, MPFR_DEFAULT_RND) == 0)
00251         calc.is_nan = TRUE;
00252     else {
00253         mpfr_fac_ui(c->mf, mpfr_get_ui(c->mf, MPFR_DEFAULT_RND), MPFR_DEFAULT_RND);
00254         if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00255     }
00256 }
00257 
00258 void rpn_not(calc_number_t *c)
00259 {
00260     mpz_t a;
00261 
00262     mpz_init(a);
00263     mpfr_get_z(a, c->mf, MPFR_DEFAULT_RND);
00264     mpz_com(a, a);
00265     mpfr_set_z(c->mf, a, MPFR_DEFAULT_RND);
00266     mpz_clear(a);
00267 }
00268 
00269 void rpn_pi(calc_number_t *c)
00270 {
00271     mpfr_const_pi(c->mf, MPFR_DEFAULT_RND);
00272 }
00273 
00274 void rpn_2pi(calc_number_t *c)
00275 {
00276     mpfr_const_pi(c->mf, MPFR_DEFAULT_RND);
00277     mpfr_mul_ui(c->mf, c->mf, 2, MPFR_DEFAULT_RND);
00278 }
00279 
00280 void rpn_sign(calc_number_t *c)
00281 {
00282     mpfr_mul_si(c->mf, c->mf, -1, MPFR_DEFAULT_RND);
00283 }
00284 
00285 void rpn_exp2(calc_number_t *c)
00286 {
00287     mpfr_sqr(c->mf, c->mf, MPFR_DEFAULT_RND);
00288     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00289 }
00290 
00291 void rpn_exp3(calc_number_t *c)
00292 {
00293     mpfr_pow_ui(c->mf, c->mf, 3, MPFR_DEFAULT_RND);
00294     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00295 }
00296 
00297 void rpn_sqrt(calc_number_t *c)
00298 {
00299     mpfr_sqrt(c->mf, c->mf, MPFR_DEFAULT_RND);
00300     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00301 }
00302 
00303 void rpn_cbrt(calc_number_t *c)
00304 {
00305     mpfr_cbrt(c->mf, c->mf, MPFR_DEFAULT_RND);
00306     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00307 }
00308 
00309 void rpn_exp(calc_number_t *c)
00310 {
00311     mpfr_exp(c->mf, c->mf, MPFR_DEFAULT_RND);
00312     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00313 }
00314 
00315 void rpn_exp10(calc_number_t *c)
00316 {
00317     mpfr_exp10(c->mf, c->mf, MPFR_DEFAULT_RND);
00318     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00319 }
00320 
00321 void rpn_ln(calc_number_t *c)
00322 {
00323     mpfr_log(c->mf, c->mf, MPFR_DEFAULT_RND);
00324     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00325 }
00326 
00327 void rpn_log(calc_number_t *c)
00328 {
00329     mpfr_log10(c->mf, c->mf, MPFR_DEFAULT_RND);
00330     if (!mpfr_number_p(c->mf)) calc.is_nan = TRUE;
00331 }
00332 
00333 static void stat_sum(mpfr_t sum)
00334 {
00335     statistic_t *p = calc.stat;
00336 
00337     mpfr_set_ui(sum, 0, MPFR_DEFAULT_RND);
00338     while (p != NULL) {
00339         mpfr_add(sum, sum, p->num.mf, MPFR_DEFAULT_RND);
00340         p = (statistic_t *)(p->next);
00341     }
00342 }
00343 
00344 void rpn_ave(calc_number_t *c)
00345 {
00346     int     n;
00347 
00348     stat_sum(c->mf);
00349     n = SendDlgItemMessage(calc.hStatWnd, IDC_LIST_STAT, LB_GETCOUNT, 0, 0);
00350 
00351     if (n)
00352         mpfr_div_ui(c->mf, c->mf, n, MPFR_DEFAULT_RND);
00353 
00354     if (calc.base != IDC_RADIO_DEC)
00355         mpfr_trunc(c->mf, c->mf);
00356 }
00357 
00358 void rpn_sum(calc_number_t *c)
00359 {
00360     stat_sum(c->mf);
00361 
00362     if (calc.base != IDC_RADIO_DEC)
00363         mpfr_trunc(c->mf, c->mf);
00364 }
00365 
00366 static void rpn_s_ex(calc_number_t *c, int pop_type)
00367 {
00368     mpfr_t        dev;
00369     mpfr_t        num;
00370     unsigned long n = 0;
00371     statistic_t  *p = calc.stat;
00372 
00373     n = SendDlgItemMessage(calc.hStatWnd, IDC_LIST_STAT, LB_GETCOUNT, 0, 0);
00374     if (n < 2) {
00375         mpfr_set_ui(c->mf, 0, MPFR_DEFAULT_RND);
00376         return;
00377     }
00378 
00379     stat_sum(c->mf);
00380     mpfr_div_ui(c->mf, c->mf, n, MPFR_DEFAULT_RND);
00381 
00382     mpfr_init(dev);
00383     mpfr_init(num);
00384 
00385     mpfr_set_ui(dev, 0, MPFR_DEFAULT_RND);
00386     p = calc.stat;
00387     while (p != NULL) {
00388         mpfr_sub(num, p->num.mf, c->mf, MPFR_DEFAULT_RND);
00389         mpfr_sqr(num, num, MPFR_DEFAULT_RND);
00390         mpfr_add(dev, dev, num, MPFR_DEFAULT_RND);
00391         p = (statistic_t *)(p->next);
00392     }
00393     mpfr_div_ui(c->mf, dev, pop_type ? n-1 : n, MPFR_DEFAULT_RND);
00394     mpfr_sqrt(c->mf, c->mf, MPFR_DEFAULT_RND);
00395 
00396     if (calc.base != IDC_RADIO_DEC)
00397         mpfr_trunc(c->mf, c->mf);
00398 
00399     mpfr_clear(dev);
00400     mpfr_clear(num);
00401 }
00402 
00403 void rpn_s(calc_number_t *c)
00404 {
00405     rpn_s_ex(c, 0);
00406 }
00407 
00408 void rpn_s_m1(calc_number_t *c)
00409 {
00410     rpn_s_ex(c, 1);
00411 }
00412 
00413 void rpn_dms2dec(calc_number_t *c)
00414 {
00415     mpfr_t d, m, s;
00416 
00417     mpfr_init(d);
00418     mpfr_init(m);
00419     mpfr_init(s);
00420 
00421     mpfr_trunc(d, c->mf);
00422     mpfr_frac(m, c->mf, MPFR_DEFAULT_RND);
00423     mpfr_mul_ui(m, m, 100, MPFR_DEFAULT_RND);
00424 
00425     mpfr_frac(s, m, MPFR_DEFAULT_RND);
00426     mpfr_trunc(m, m);
00427     mpfr_mul_ui(s, s, 100, MPFR_DEFAULT_RND);
00428     mpfr_ceil(s, s);
00429 
00430     mpfr_div_ui(m, m, 60, MPFR_DEFAULT_RND);
00431     mpfr_div_ui(s, s, 3600, MPFR_DEFAULT_RND);
00432     mpfr_add(c->mf, d, m, MPFR_DEFAULT_RND);
00433     mpfr_add(c->mf, c->mf, s, MPFR_DEFAULT_RND);
00434 
00435     mpfr_clear(d);
00436     mpfr_clear(m);
00437     mpfr_clear(s);
00438 }
00439 
00440 void rpn_dec2dms(calc_number_t *c)
00441 {
00442     mpfr_t d, m, s;
00443 
00444     mpfr_init(d);
00445     mpfr_init(m);
00446     mpfr_init(s);
00447 
00448     mpfr_trunc(d, c->mf);
00449     mpfr_frac(m, c->mf, MPFR_DEFAULT_RND);
00450     mpfr_mul_ui(m, m, 60, MPFR_DEFAULT_RND);
00451 
00452     mpfr_frac(s, m, MPFR_DEFAULT_RND);
00453     mpfr_trunc(m, m);
00454     mpfr_mul_ui(s, s, 60, MPFR_DEFAULT_RND);
00455     mpfr_ceil(s, s);
00456 
00457     mpfr_div_ui(m, m, 100, MPFR_DEFAULT_RND);
00458     mpfr_div_ui(s, s, 10000, MPFR_DEFAULT_RND);
00459     mpfr_add(c->mf, d, m, MPFR_DEFAULT_RND);
00460     mpfr_add(c->mf, c->mf, s, MPFR_DEFAULT_RND);
00461 
00462     mpfr_clear(d);
00463     mpfr_clear(m);
00464     mpfr_clear(s);
00465 }
00466 
00467 void rpn_zero(calc_number_t *c)
00468 {
00469     mpfr_set_ui(c->mf, 0, MPFR_DEFAULT_RND);
00470 }
00471 
00472 void rpn_copy(calc_number_t *dst, calc_number_t *src)
00473 {
00474     mpfr_set(dst->mf, src->mf, MPFR_DEFAULT_RND);
00475 }
00476 
00477 int rpn_is_zero(calc_number_t *c)
00478 {
00479     return (mpfr_sgn(c->mf) == 0);
00480 }
00481 
00482 void rpn_alloc(calc_number_t *c)
00483 {
00484     mpfr_init(c->mf);
00485 }
00486 
00487 void rpn_free(calc_number_t *c)
00488 {
00489     mpfr_clear(c->mf);
00490 }
Generated on Thu Feb 9 04:38:57 2012 for ReactOS by
1.6.3