| 25 |
25 |
VALUE rb_mMath;
|
| 26 |
26 |
VALUE rb_eMathDomainError;
|
| 27 |
27 |
|
| 28 |
|
#define Need_Float(x) do {if (!RB_TYPE_P(x, T_FLOAT)) {(x) = rb_to_float(x);}} while(0)
|
| 29 |
|
#define Need_Float2(x,y) do {\
|
| 30 |
|
Need_Float(x);\
|
| 31 |
|
Need_Float(y);\
|
| 32 |
|
} while (0)
|
|
28 |
#define Get_RFloat_Value(x) RFLOAT_VALUE(RB_TYPE_P(x, T_FLOAT) ? x : rb_to_float(x))
|
| 33 |
29 |
|
| 34 |
30 |
#define domain_error(msg) \
|
| 35 |
31 |
rb_raise(rb_eMathDomainError, "Numerical argument is out of domain - " #msg)
|
| ... | ... | |
| 69 |
65 |
# define M_PI 3.14159265358979323846
|
| 70 |
66 |
#endif
|
| 71 |
67 |
double dx, dy;
|
| 72 |
|
Need_Float2(y, x);
|
| 73 |
|
dx = RFLOAT_VALUE(x);
|
| 74 |
|
dy = RFLOAT_VALUE(y);
|
|
68 |
dx = Get_RFloat_Value(x);
|
|
69 |
dy = Get_RFloat_Value(y);
|
| 75 |
70 |
if (dx == 0.0 && dy == 0.0) {
|
| 76 |
71 |
if (!signbit(dx))
|
| 77 |
72 |
return DBL2NUM(dy);
|
| ... | ... | |
| 114 |
109 |
static VALUE
|
| 115 |
110 |
math_cos(VALUE obj, VALUE x)
|
| 116 |
111 |
{
|
| 117 |
|
Need_Float(x);
|
| 118 |
|
return DBL2NUM(cos(RFLOAT_VALUE(x)));
|
|
112 |
return DBL2NUM(cos(Get_RFloat_Value(x)));
|
| 119 |
113 |
}
|
| 120 |
114 |
|
| 121 |
115 |
/*
|
| ... | ... | |
| 136 |
130 |
static VALUE
|
| 137 |
131 |
math_sin(VALUE obj, VALUE x)
|
| 138 |
132 |
{
|
| 139 |
|
Need_Float(x);
|
| 140 |
|
return DBL2NUM(sin(RFLOAT_VALUE(x)));
|
|
133 |
return DBL2NUM(sin(Get_RFloat_Value(x)));
|
| 141 |
134 |
}
|
| 142 |
135 |
|
| 143 |
136 |
|
| ... | ... | |
| 158 |
151 |
static VALUE
|
| 159 |
152 |
math_tan(VALUE obj, VALUE x)
|
| 160 |
153 |
{
|
| 161 |
|
Need_Float(x);
|
| 162 |
|
return DBL2NUM(tan(RFLOAT_VALUE(x)));
|
|
154 |
return DBL2NUM(tan(Get_RFloat_Value(x)));
|
| 163 |
155 |
}
|
| 164 |
156 |
|
| 165 |
157 |
/*
|
| ... | ... | |
| 181 |
173 |
{
|
| 182 |
174 |
double d0, d;
|
| 183 |
175 |
|
| 184 |
|
Need_Float(x);
|
| 185 |
|
d0 = RFLOAT_VALUE(x);
|
|
176 |
d0 = Get_RFloat_Value(x);
|
| 186 |
177 |
/* check for domain error */
|
| 187 |
178 |
if (d0 < -1.0 || 1.0 < d0) domain_error("acos");
|
| 188 |
179 |
d = acos(d0);
|
| ... | ... | |
| 207 |
198 |
{
|
| 208 |
199 |
double d0, d;
|
| 209 |
200 |
|
| 210 |
|
Need_Float(x);
|
| 211 |
|
d0 = RFLOAT_VALUE(x);
|
|
201 |
d0 = Get_RFloat_Value(x);
|
| 212 |
202 |
/* check for domain error */
|
| 213 |
203 |
if (d0 < -1.0 || 1.0 < d0) domain_error("asin");
|
| 214 |
204 |
d = asin(d0);
|
| ... | ... | |
| 231 |
221 |
static VALUE
|
| 232 |
222 |
math_atan(VALUE obj, VALUE x)
|
| 233 |
223 |
{
|
| 234 |
|
Need_Float(x);
|
| 235 |
|
return DBL2NUM(atan(RFLOAT_VALUE(x)));
|
|
224 |
return DBL2NUM(atan(Get_RFloat_Value(x)));
|
| 236 |
225 |
}
|
| 237 |
226 |
|
| 238 |
227 |
#ifndef HAVE_COSH
|
| ... | ... | |
| 260 |
249 |
static VALUE
|
| 261 |
250 |
math_cosh(VALUE obj, VALUE x)
|
| 262 |
251 |
{
|
| 263 |
|
Need_Float(x);
|
| 264 |
|
return DBL2NUM(cosh(RFLOAT_VALUE(x)));
|
|
252 |
return DBL2NUM(cosh(Get_RFloat_Value(x)));
|
| 265 |
253 |
}
|
| 266 |
254 |
|
| 267 |
255 |
#ifndef HAVE_SINH
|
| ... | ... | |
| 289 |
277 |
static VALUE
|
| 290 |
278 |
math_sinh(VALUE obj, VALUE x)
|
| 291 |
279 |
{
|
| 292 |
|
Need_Float(x);
|
| 293 |
|
return DBL2NUM(sinh(RFLOAT_VALUE(x)));
|
|
280 |
return DBL2NUM(sinh(Get_RFloat_Value(x)));
|
| 294 |
281 |
}
|
| 295 |
282 |
|
| 296 |
283 |
#ifndef HAVE_TANH
|
| ... | ... | |
| 318 |
305 |
static VALUE
|
| 319 |
306 |
math_tanh(VALUE obj, VALUE x)
|
| 320 |
307 |
{
|
| 321 |
|
Need_Float(x);
|
| 322 |
|
return DBL2NUM(tanh(RFLOAT_VALUE(x)));
|
|
308 |
return DBL2NUM(tanh(Get_RFloat_Value(x)));
|
| 323 |
309 |
}
|
| 324 |
310 |
|
| 325 |
311 |
/*
|
| ... | ... | |
| 341 |
327 |
{
|
| 342 |
328 |
double d0, d;
|
| 343 |
329 |
|
| 344 |
|
Need_Float(x);
|
| 345 |
|
d0 = RFLOAT_VALUE(x);
|
|
330 |
d0 = Get_RFloat_Value(x);
|
| 346 |
331 |
/* check for domain error */
|
| 347 |
332 |
if (d0 < 1.0) domain_error("acosh");
|
| 348 |
333 |
d = acosh(d0);
|
| ... | ... | |
| 366 |
351 |
static VALUE
|
| 367 |
352 |
math_asinh(VALUE obj, VALUE x)
|
| 368 |
353 |
{
|
| 369 |
|
Need_Float(x);
|
| 370 |
|
return DBL2NUM(asinh(RFLOAT_VALUE(x)));
|
|
354 |
return DBL2NUM(asinh(Get_RFloat_Value(x)));
|
| 371 |
355 |
}
|
| 372 |
356 |
|
| 373 |
357 |
/*
|
| ... | ... | |
| 389 |
373 |
{
|
| 390 |
374 |
double d0, d;
|
| 391 |
375 |
|
| 392 |
|
Need_Float(x);
|
| 393 |
|
d0 = RFLOAT_VALUE(x);
|
|
376 |
d0 = Get_RFloat_Value(x);
|
| 394 |
377 |
/* check for domain error */
|
| 395 |
378 |
if (d0 < -1.0 || +1.0 < d0) domain_error("atanh");
|
| 396 |
379 |
/* check for pole error */
|
| ... | ... | |
| 419 |
402 |
static VALUE
|
| 420 |
403 |
math_exp(VALUE obj, VALUE x)
|
| 421 |
404 |
{
|
| 422 |
|
Need_Float(x);
|
| 423 |
|
return DBL2NUM(exp(RFLOAT_VALUE(x)));
|
|
405 |
return DBL2NUM(exp(Get_RFloat_Value(x)));
|
| 424 |
406 |
}
|
| 425 |
407 |
|
| 426 |
408 |
#if defined __CYGWIN__
|
| ... | ... | |
| 484 |
466 |
numbits = 0;
|
| 485 |
467 |
}
|
| 486 |
468 |
|
| 487 |
|
Need_Float(x);
|
| 488 |
|
d0 = RFLOAT_VALUE(x);
|
|
469 |
d0 = Get_RFloat_Value(x);
|
| 489 |
470 |
/* check for domain error */
|
| 490 |
471 |
if (d0 < 0.0) domain_error("log");
|
| 491 |
472 |
/* check for pole error */
|
| ... | ... | |
| 540 |
521 |
numbits = 0;
|
| 541 |
522 |
}
|
| 542 |
523 |
|
| 543 |
|
Need_Float(x);
|
| 544 |
|
d0 = RFLOAT_VALUE(x);
|
|
524 |
d0 = Get_RFloat_Value(x);
|
| 545 |
525 |
/* check for domain error */
|
| 546 |
526 |
if (d0 < 0.0) domain_error("log2");
|
| 547 |
527 |
/* check for pole error */
|
| ... | ... | |
| 582 |
562 |
numbits = 0;
|
| 583 |
563 |
}
|
| 584 |
564 |
|
| 585 |
|
Need_Float(x);
|
| 586 |
|
d0 = RFLOAT_VALUE(x);
|
|
565 |
d0 = Get_RFloat_Value(x);
|
| 587 |
566 |
/* check for domain error */
|
| 588 |
567 |
if (d0 < 0.0) domain_error("log10");
|
| 589 |
568 |
/* check for pole error */
|
| ... | ... | |
| 625 |
604 |
{
|
| 626 |
605 |
double d0, d;
|
| 627 |
606 |
|
| 628 |
|
Need_Float(x);
|
| 629 |
|
d0 = RFLOAT_VALUE(x);
|
|
607 |
d0 = Get_RFloat_Value(x);
|
| 630 |
608 |
/* check for domain error */
|
| 631 |
609 |
if (d0 < 0.0) domain_error("sqrt");
|
| 632 |
610 |
if (d0 == 0.0) return DBL2NUM(0.0);
|
| ... | ... | |
| 672 |
650 |
static VALUE
|
| 673 |
651 |
math_cbrt(VALUE obj, VALUE x)
|
| 674 |
652 |
{
|
| 675 |
|
Need_Float(x);
|
| 676 |
|
return DBL2NUM(cbrt(RFLOAT_VALUE(x)));
|
|
653 |
return DBL2NUM(cbrt(Get_RFloat_Value(x)));
|
| 677 |
654 |
}
|
| 678 |
655 |
|
| 679 |
656 |
/*
|
| ... | ... | |
| 693 |
670 |
double d;
|
| 694 |
671 |
int exp;
|
| 695 |
672 |
|
| 696 |
|
Need_Float(x);
|
| 697 |
|
|
| 698 |
|
d = frexp(RFLOAT_VALUE(x), &exp);
|
|
673 |
d = frexp(Get_RFloat_Value(x), &exp);
|
| 699 |
674 |
return rb_assoc_new(DBL2NUM(d), INT2NUM(exp));
|
| 700 |
675 |
}
|
| 701 |
676 |
|
| ... | ... | |
| 712 |
687 |
static VALUE
|
| 713 |
688 |
math_ldexp(VALUE obj, VALUE x, VALUE n)
|
| 714 |
689 |
{
|
| 715 |
|
Need_Float(x);
|
| 716 |
|
return DBL2NUM(ldexp(RFLOAT_VALUE(x), NUM2INT(n)));
|
|
690 |
return DBL2NUM(ldexp(Get_RFloat_Value(x), NUM2INT(n)));
|
| 717 |
691 |
}
|
| 718 |
692 |
|
| 719 |
693 |
/*
|
| ... | ... | |
| 729 |
703 |
static VALUE
|
| 730 |
704 |
math_hypot(VALUE obj, VALUE x, VALUE y)
|
| 731 |
705 |
{
|
| 732 |
|
Need_Float2(x, y);
|
| 733 |
|
return DBL2NUM(hypot(RFLOAT_VALUE(x), RFLOAT_VALUE(y)));
|
|
706 |
return DBL2NUM(hypot(Get_RFloat_Value(x), Get_RFloat_Value(y)));
|
| 734 |
707 |
}
|
| 735 |
708 |
|
| 736 |
709 |
/*
|
| ... | ... | |
| 750 |
723 |
static VALUE
|
| 751 |
724 |
math_erf(VALUE obj, VALUE x)
|
| 752 |
725 |
{
|
| 753 |
|
Need_Float(x);
|
| 754 |
|
return DBL2NUM(erf(RFLOAT_VALUE(x)));
|
|
726 |
return DBL2NUM(erf(Get_RFloat_Value(x)));
|
| 755 |
727 |
}
|
| 756 |
728 |
|
| 757 |
729 |
/*
|
| ... | ... | |
| 771 |
743 |
static VALUE
|
| 772 |
744 |
math_erfc(VALUE obj, VALUE x)
|
| 773 |
745 |
{
|
| 774 |
|
Need_Float(x);
|
| 775 |
|
return DBL2NUM(erfc(RFLOAT_VALUE(x)));
|
|
746 |
return DBL2NUM(erfc(Get_RFloat_Value(x)));
|
| 776 |
747 |
}
|
| 777 |
748 |
|
| 778 |
749 |
/*
|
| ... | ... | |
| 848 |
819 |
};
|
| 849 |
820 |
double d0, d;
|
| 850 |
821 |
double intpart, fracpart;
|
| 851 |
|
Need_Float(x);
|
| 852 |
|
d0 = RFLOAT_VALUE(x);
|
|
822 |
d0 = Get_RFloat_Value(x);
|
| 853 |
823 |
/* check for domain error */
|
| 854 |
824 |
if (isinf(d0) && signbit(d0)) domain_error("gamma");
|
| 855 |
825 |
fracpart = modf(d0, &intpart);
|
| ... | ... | |
| 884 |
854 |
double d0, d;
|
| 885 |
855 |
int sign=1;
|
| 886 |
856 |
VALUE v;
|
| 887 |
|
Need_Float(x);
|
| 888 |
|
d0 = RFLOAT_VALUE(x);
|
|
857 |
d0 = Get_RFloat_Value(x);
|
| 889 |
858 |
/* check for domain error */
|
| 890 |
859 |
if (isinf(d0)) {
|
| 891 |
860 |
if (signbit(d0)) domain_error("lgamma");
|
| 892 |
|
-
|