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 |
|
-
|