| blob | a36370b9a46e9c310bba006ce6cfcb3a57679203 |
1 /**********************************************************************
3 numeric.c -
5 $Author$
6 created at: Fri Aug 13 18:33:09 JST 1993
8 Copyright (C) 1993-2007 Yukihiro Matsumoto
10 **********************************************************************/
14 #include <assert.h>
15 #include <ctype.h>
16 #include <math.h>
17 #include <stdio.h>
19 #ifdef HAVE_FLOAT_H
20 #include <float.h>
21 #endif
23 #ifdef HAVE_IEEEFP_H
24 #include <ieeefp.h>
25 #endif
45 /* use IEEE 64bit values if not defined */
46 #ifndef FLT_RADIX
47 #define FLT_RADIX 2
48 #endif
49 #ifndef DBL_MIN
50 #define DBL_MIN 2.2250738585072014e-308
51 #endif
52 #ifndef DBL_MAX
53 #define DBL_MAX 1.7976931348623157e+308
54 #endif
55 #ifndef DBL_MIN_EXP
56 #define DBL_MIN_EXP (-1021)
57 #endif
58 #ifndef DBL_MAX_EXP
59 #define DBL_MAX_EXP 1024
60 #endif
61 #ifndef DBL_MIN_10_EXP
62 #define DBL_MIN_10_EXP (-307)
63 #endif
64 #ifndef DBL_MAX_10_EXP
65 #define DBL_MAX_10_EXP 308
66 #endif
67 #ifndef DBL_DIG
68 #define DBL_DIG 15
69 #endif
70 #ifndef DBL_MANT_DIG
71 #define DBL_MANT_DIG 53
72 #endif
73 #ifndef DBL_EPSILON
74 #define DBL_EPSILON 2.2204460492503131e-16
75 #endif
77 #ifndef USE_RB_INFINITY
80 #else
82 #endif
84 #ifndef USE_RB_NAN
87 #else
89 #endif
91 #ifndef HAVE_ROUND
92 double
94 {
100 }
104 }
106 }
107 #endif
109 static double
111 {
119 }
123 }
125 }
127 static double
129 {
136 }
140 }
142 }
144 static double
146 {
161 else
164 }
173 else
176 }
178 }
190 #define id_div idDiv
191 #define id_divmod idDivmod
192 #define id_to_i idTo_i
193 #define id_eq idEq
194 #define id_cmp idCmp
196 VALUE rb_cNumeric;
197 VALUE rb_cFloat;
198 VALUE rb_cInteger;
200 VALUE rb_eZeroDivError;
201 VALUE rb_eFloatDomainError;
205 void
207 {
209 }
211 enum ruby_num_rounding_mode
213 {
215 VALUE rounding;
216 VALUE str;
222 }
226 }
229 }
233 }
247 }
248 invalid:
250 }
251 noopt:
253 }
255 /* experimental API */
256 int
258 {
259 #define NUMERR_TYPE 1
260 #define NUMERR_NEGATIVE 2
261 #define NUMERR_TOOLARGE 3
264 #if SIZEOF_INT < SIZEOF_LONG
266 #endif
270 }
274 #if SIZEOF_INT < SIZEOF_LONG
275 /* long is 64bit */
277 #else
278 /* long is 32bit */
282 #endif
283 }
285 }
287 #define method_basic_p(klass) rb_method_basic_definition_p(klass, mid)
291 {
294 }
297 }
299 }
303 {
306 }
309 }
311 }
313 int
315 {
317 }
319 int
321 {
323 }
325 int
327 {
329 }
331 static VALUE
333 {
340 }
344 }
348 }
349 }
351 }
353 static VALUE
355 {
357 }
361 static void
363 {
368 }
372 }
373 }
375 static VALUE
377 {
382 }
384 }
386 static VALUE
388 {
393 }
395 /*
396 * call-seq:
397 * coerce(other) -> array
398 *
399 * Returns a 2-element array containing two numeric elements,
400 * formed from the two operands +self+ and +other+,
401 * of a common compatible type.
402 *
403 * Of the Core and Standard Library classes,
404 * Integer, Rational, and Complex use this implementation.
405 *
406 * Examples:
407 *
408 * i = 2 # => 2
409 * i.coerce(3) # => [3, 2]
410 * i.coerce(3.0) # => [3.0, 2.0]
411 * i.coerce(Rational(1, 2)) # => [0.5, 2.0]
412 * i.coerce(Complex(3, 4)) # Raises RangeError.
413 *
414 * r = Rational(5, 2) # => (5/2)
415 * r.coerce(2) # => [(2/1), (5/2)]
416 * r.coerce(2.0) # => [2.0, 2.5]
417 * r.coerce(Rational(2, 3)) # => [(2/3), (5/2)]
418 * r.coerce(Complex(3, 4)) # => [(3+4i), ((5/2)+0i)]
419 *
420 * c = Complex(2, 3) # => (2+3i)
421 * c.coerce(2) # => [(2+0i), (2+3i)]
422 * c.coerce(2.0) # => [(2.0+0i), (2+3i)]
423 * c.coerce(Rational(1, 2)) # => [((1/2)+0i), (2+3i)]
424 * c.coerce(Complex(3, 4)) # => [(3+4i), (2+3i)]
425 *
426 * Raises an exception if any type conversion fails.
427 *
428 */
430 static VALUE
432 {
438 }
441 static void
443 {
446 }
449 }
452 }
454 static int
456 {
461 }
463 }
466 }
469 }
474 }
476 VALUE
478 {
481 }
483 VALUE
485 {
489 }
491 static VALUE
493 {
496 }
498 VALUE
500 {
506 }
508 }
512 /*
513 * :nodoc:
514 *
515 * Trap attempts to add methods to Numeric objects. Always raises a TypeError.
516 *
517 * Numerics should be values; singleton_methods should not be added to them.
518 */
520 static VALUE
522 {
532 }
534 #if 0
535 /*
536 * call-seq:
537 * clone(freeze: true) -> self
538 *
539 * Returns +self+.
540 *
541 * Raises an exception if the value for +freeze+ is neither +true+ nor +nil+.
542 *
543 * Related: Numeric#dup.
544 *
545 */
546 static VALUE
548 {
550 }
551 #else
552 # define num_clone rb_immutable_obj_clone
553 #endif
555 /*
556 * call-seq:
557 * i -> complex
558 *
559 * Returns <tt>Complex(0, self)</tt>:
560 *
561 * 2.i # => (0+2i)
562 * -2.i # => (0-2i)
563 * 2.0.i # => (0+2.0i)
564 * Rational(1, 2).i # => (0+(1/2)*i)
565 * Complex(3, 4).i # Raises NoMethodError.
566 *
567 */
569 static VALUE
571 {
573 }
575 /*
576 * call-seq:
577 * -self -> numeric
578 *
579 * Unary Minus---Returns the receiver, negated.
580 */
582 static VALUE
584 {
585 VALUE zero;
591 }
593 /*
594 * call-seq:
595 * fdiv(other) -> float
596 *
597 * Returns the quotient <tt>self/other</tt> as a float,
598 * using method +/+ in the derived class of +self+.
599 * (\Numeric itself does not define method +/+.)
600 *
601 * Of the Core and Standard Library classes,
602 * only BigDecimal uses this implementation.
603 *
604 */
606 static VALUE
608 {
610 }
612 /*
613 * call-seq:
614 * div(other) -> integer
615 *
616 * Returns the quotient <tt>self/other</tt> as an integer (via +floor+),
617 * using method +/+ in the derived class of +self+.
618 * (\Numeric itself does not define method +/+.)
619 *
620 * Of the Core and Standard Library classes,
621 * Only Float and Rational use this implementation.
622 *
623 */
625 static VALUE
627 {
630 }
632 /*
633 * call-seq:
634 * self % other -> real_numeric
635 *
636 * Returns +self+ modulo +other+ as a real number.
637 *
638 * Of the Core and Standard Library classes,
639 * only Rational uses this implementation.
640 *
641 * For Rational +r+ and real number +n+, these expressions are equivalent:
642 *
643 * r % n
644 * r-n*(r/n).floor
645 * r.divmod(n)[1]
646 *
647 * See Numeric#divmod.
648 *
649 * Examples:
650 *
651 * r = Rational(1, 2) # => (1/2)
652 * r2 = Rational(2, 3) # => (2/3)
653 * r % r2 # => (1/2)
654 * r % 2 # => (1/2)
655 * r % 2.0 # => 0.5
656 *
657 * r = Rational(301,100) # => (301/100)
658 * r2 = Rational(7,5) # => (7/5)
659 * r % r2 # => (21/100)
660 * r % -r2 # => (-119/100)
661 * (-r) % r2 # => (119/100)
662 * (-r) %-r2 # => (-21/100)
663 *
664 */
666 static VALUE
668 {
672 }
674 /*
675 * call-seq:
676 * remainder(other) -> real_number
677 *
678 * Returns the remainder after dividing +self+ by +other+.
679 *
680 * Of the Core and Standard Library classes,
681 * only Float and Rational use this implementation.
682 *
683 * Examples:
684 *
685 * 11.0.remainder(4) # => 3.0
686 * 11.0.remainder(-4) # => 3.0
687 * -11.0.remainder(4) # => -3.0
688 * -11.0.remainder(-4) # => -3.0
689 *
690 * 12.0.remainder(4) # => 0.0
691 * 12.0.remainder(-4) # => 0.0
692 * -12.0.remainder(4) # => -0.0
693 * -12.0.remainder(-4) # => -0.0
694 *
695 * 13.0.remainder(4.0) # => 1.0
696 * 13.0.remainder(Rational(4, 1)) # => 1.0
697 *
698 * Rational(13, 1).remainder(4) # => (1/1)
699 * Rational(13, 1).remainder(-4) # => (1/1)
700 * Rational(-13, 1).remainder(4) # => (-1/1)
701 * Rational(-13, 1).remainder(-4) # => (-1/1)
702 *
703 */
705 static VALUE
707 {
710 }
721 }
722 }
724 }
726 }
728 /*
729 * call-seq:
730 * divmod(other) -> array
731 *
732 * Returns a 2-element array <tt>[q, r]</tt>, where
733 *
734 * q = (self/other).floor # Quotient
735 * r = self % other # Remainder
736 *
737 * Of the Core and Standard Library classes,
738 * only Rational uses this implementation.
739 *
740 * Examples:
741 *
742 * Rational(11, 1).divmod(4) # => [2, (3/1)]
743 * Rational(11, 1).divmod(-4) # => [-3, (-1/1)]
744 * Rational(-11, 1).divmod(4) # => [-3, (1/1)]
745 * Rational(-11, 1).divmod(-4) # => [2, (-3/1)]
746 *
747 * Rational(12, 1).divmod(4) # => [3, (0/1)]
748 * Rational(12, 1).divmod(-4) # => [-3, (0/1)]
749 * Rational(-12, 1).divmod(4) # => [-3, (0/1)]
750 * Rational(-12, 1).divmod(-4) # => [3, (0/1)]
751 *
752 * Rational(13, 1).divmod(4.0) # => [3, 1.0]
753 * Rational(13, 1).divmod(Rational(4, 11)) # => [35, (3/11)]
754 */
756 static VALUE
758 {
760 }
762 /*
763 * call-seq:
764 * abs -> numeric
765 *
766 * Returns the absolute value of +self+.
767 *
768 * 12.abs #=> 12
769 * (-34.56).abs #=> 34.56
770 * -34.56.abs #=> 34.56
771 *
772 */
774 static VALUE
776 {
779 }
781 }
783 /*
784 * call-seq:
785 * zero? -> true or false
786 *
787 * Returns +true+ if +zero+ has a zero value, +false+ otherwise.
788 *
789 * Of the Core and Standard Library classes,
790 * only Rational and Complex use this implementation.
791 *
792 */
794 static VALUE
796 {
798 }
800 static bool
802 {
805 }
808 }
810 VALUE
812 {
814 }
816 /*
817 * call-seq:
818 * nonzero? -> self or nil
819 *
820 * Returns +self+ if +self+ is not a zero value, +nil+ otherwise;
821 * uses method <tt>zero?</tt> for the evaluation.
822 *
823 * The returned +self+ allows the method to be chained:
824 *
825 * a = %w[z Bb bB bb BB a aA Aa AA A]
826 * a.sort {|a, b| (a.downcase <=> b.downcase).nonzero? || a <=> b }
827 * # => ["A", "a", "AA", "Aa", "aA", "BB", "Bb", "bB", "bb", "z"]
828 *
829 * Of the Core and Standard Library classes,
830 * Integer, Float, Rational, and Complex use this implementation.
831 *
832 * Related: #zero?
833 *
834 */
836 static VALUE
838 {
841 }
843 }
845 /*
846 * call-seq:
847 * to_int -> integer
848 *
849 * Returns +self+ as an integer;
850 * converts using method +to_i+ in the derived class.
851 *
852 * Of the Core and Standard Library classes,
853 * only Rational and Complex use this implementation.
854 *
855 * Examples:
856 *
857 * Rational(1, 2).to_int # => 0
858 * Rational(2, 1).to_int # => 2
859 * Complex(2, 0).to_int # => 2
860 * Complex(2, 1) # Raises RangeError (non-zero imaginary part)
861 *
862 */
864 static VALUE
866 {
868 }
870 /*
871 * call-seq:
872 * positive? -> true or false
873 *
874 * Returns +true+ if +self+ is greater than 0, +false+ otherwise.
875 *
876 */
878 static VALUE
880 {
886 }
890 }
892 }
894 /*
895 * call-seq:
896 * negative? -> true or false
897 *
898 * Returns +true+ if +self+ is less than 0, +false+ otherwise.
899 *
900 */
902 static VALUE
904 {
906 }
909 /********************************************************************
910 *
911 * Document-class: Float
912 *
913 * A \Float object represents a sometimes-inexact real number using the native
914 * architecture's double-precision floating point representation.
915 *
916 * Floating point has a different arithmetic and is an inexact number.
917 * So you should know its esoteric system. See following:
918 *
919 * - https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html
920 * - https://github.com/rdp/ruby_tutorials_core/wiki/Ruby-Talk-FAQ#-why-are-rubys-floats-imprecise
921 * - https://en.wikipedia.org/wiki/Floating_point#Accuracy_problems
922 *
923 * You can create a \Float object explicitly with:
924 *
925 * - A {floating-point literal}[rdoc-ref:syntax/literals.rdoc@Float+Literals].
926 *
927 * You can convert certain objects to Floats with:
928 *
929 * - \Method #Float.
930 *
931 * == What's Here
932 *
933 * First, what's elsewhere. \Class \Float:
934 *
935 * - Inherits from
936 * {class Numeric}[rdoc-ref:Numeric@What-27s+Here]
937 * and {class Object}[rdoc-ref:Object@What-27s+Here].
938 * - Includes {module Comparable}[rdoc-ref:Comparable@What-27s+Here].
939 *
940 * Here, class \Float provides methods for:
941 *
942 * - {Querying}[rdoc-ref:Float@Querying]
943 * - {Comparing}[rdoc-ref:Float@Comparing]
944 * - {Converting}[rdoc-ref:Float@Converting]
945 *
946 * === Querying
947 *
948 * - #finite?: Returns whether +self+ is finite.
949 * - #hash: Returns the integer hash code for +self+.
950 * - #infinite?: Returns whether +self+ is infinite.
951 * - #nan?: Returns whether +self+ is a NaN (not-a-number).
952 *
953 * === Comparing
954 *
955 * - #<: Returns whether +self+ is less than the given value.
956 * - #<=: Returns whether +self+ is less than or equal to the given value.
957 * - #<=>: Returns a number indicating whether +self+ is less than, equal
958 * to, or greater than the given value.
959 * - #== (aliased as #=== and #eql?): Returns whether +self+ is equal to
960 * the given value.
961 * - #>: Returns whether +self+ is greater than the given value.
962 * - #>=: Returns whether +self+ is greater than or equal to the given value.
963 *
964 * === Converting
965 *
966 * - #% (aliased as #modulo): Returns +self+ modulo the given value.
967 * - #*: Returns the product of +self+ and the given value.
968 * - #**: Returns the value of +self+ raised to the power of the given value.
969 * - #+: Returns the sum of +self+ and the given value.
970 * - #-: Returns the difference of +self+ and the given value.
971 * - #/: Returns the quotient of +self+ and the given value.
972 * - #ceil: Returns the smallest number greater than or equal to +self+.
973 * - #coerce: Returns a 2-element array containing the given value converted to a \Float
974 * and +self+
975 * - #divmod: Returns a 2-element array containing the quotient and remainder
976 * results of dividing +self+ by the given value.
977 * - #fdiv: Returns the \Float result of dividing +self+ by the given value.
978 * - #floor: Returns the greatest number smaller than or equal to +self+.
979 * - #next_float: Returns the next-larger representable \Float.
980 * - #prev_float: Returns the next-smaller representable \Float.
981 * - #quo: Returns the quotient from dividing +self+ by the given value.
982 * - #round: Returns +self+ rounded to the nearest value, to a given precision.
983 * - #to_i (aliased as #to_int): Returns +self+ truncated to an Integer.
984 * - #to_s (aliased as #inspect): Returns a string containing the place-value
985 * representation of +self+ in the given radix.
986 * - #truncate: Returns +self+ truncated to a given precision.
987 *
988 */
990 VALUE
992 {
993 NEWOBJ_OF(flt, struct RFloat, rb_cFloat, T_FLOAT | (RGENGC_WB_PROTECTED_FLOAT ? FL_WB_PROTECTED : 0), sizeof(struct RFloat), 0);
995 #if SIZEOF_DOUBLE <= SIZEOF_VALUE
997 #else
1000 rb_float_value_type v;
1003 #endif
1006 }
1008 /*
1009 * call-seq:
1010 * to_s -> string
1011 *
1012 * Returns a string containing a representation of +self+;
1013 * depending of the value of +self+, the string representation
1014 * may contain:
1015 *
1016 * - A fixed-point number.
1017 * 3.14.to_s # => "3.14"
1018 * - A number in "scientific notation" (containing an exponent).
1019 * (10.1**50).to_s # => "1.644631821843879e+50"
1020 * - 'Infinity'.
1021 * (10.1**500).to_s # => "Infinity"
1022 * - '-Infinity'.
1023 * (-10.1**500).to_s # => "-Infinity"
1024 * - 'NaN' (indicating not-a-number).
1025 * (0.0/0.0).to_s # => "NaN"
1026 *
1027 */
1029 static VALUE
1031 {
1036 VALUE s;
1044 }
1058 }
1068 }
1070 }
1073 }
1074 }
1083 }
1086 }
1089 exp:
1092 }
1095 digs++;
1096 }
1101 }
1103 /*
1104 * call-seq:
1105 * coerce(other) -> array
1106 *
1107 * Returns a 2-element array containing +other+ converted to a \Float
1108 * and +self+:
1109 *
1110 * f = 3.14 # => 3.14
1111 * f.coerce(2) # => [2.0, 3.14]
1112 * f.coerce(2.0) # => [2.0, 3.14]
1113 * f.coerce(Rational(1, 2)) # => [0.5, 3.14]
1114 * f.coerce(Complex(1, 0)) # => [1.0, 3.14]
1115 *
1116 * Raises an exception if a type conversion fails.
1117 *
1118 */
1120 static VALUE
1122 {
1124 }
1126 VALUE
1128 {
1130 }
1132 /*
1133 * call-seq:
1134 * self + other -> numeric
1135 *
1136 * Returns a new \Float which is the sum of +self+ and +other+:
1137 *
1138 * f = 3.14
1139 * f + 1 # => 4.140000000000001
1140 * f + 1.0 # => 4.140000000000001
1141 * f + Rational(1, 1) # => 4.140000000000001
1142 * f + Complex(1, 0) # => (4.140000000000001+0i)
1143 *
1144 */
1146 VALUE
1148 {
1151 }
1154 }
1157 }
1160 }
1161 }
1163 /*
1164 * call-seq:
1165 * self - other -> numeric
1166 *
1167 * Returns a new \Float which is the difference of +self+ and +other+:
1168 *
1169 * f = 3.14
1170 * f - 1 # => 2.14
1171 * f - 1.0 # => 2.14
1172 * f - Rational(1, 1) # => 2.14
1173 * f - Complex(1, 0) # => (2.14+0i)
1174 *
1175 */
1177 VALUE
1179 {
1182 }
1185 }
1188 }
1191 }
1192 }
1194 /*
1195 * call-seq:
1196 * self * other -> numeric
1197 *
1198 * Returns a new \Float which is the product of +self+ and +other+:
1199 *
1200 * f = 3.14
1201 * f * 2 # => 6.28
1202 * f * 2.0 # => 6.28
1203 * f * Rational(1, 2) # => 1.57
1204 * f * Complex(2, 0) # => (6.28+0.0i)
1205 */
1207 VALUE
1209 {
1212 }
1215 }
1218 }
1221 }
1222 }
1224 static double
1226 {
1229 }
1232 }
1236 }
1237 }
1239 VALUE
1241 {
1246 }
1248 /*
1249 * call-seq:
1250 * self / other -> numeric
1251 *
1252 * Returns a new \Float which is the result of dividing +self+ by +other+:
1253 *
1254 * f = 3.14
1255 * f / 2 # => 1.57
1256 * f / 2.0 # => 1.57
1257 * f / Rational(2, 1) # => 1.57
1258 * f / Complex(2, 0) # => (1.57+0.0i)
1259 *
1260 */
1262 VALUE
1264 {
1271 }
1274 }
1277 }
1280 }
1284 }
1286 /*
1287 * call-seq:
1288 * quo(other) -> numeric
1289 *
1290 * Returns the quotient from dividing +self+ by +other+:
1291 *
1292 * f = 3.14
1293 * f.quo(2) # => 1.57
1294 * f.quo(-2) # => -1.57
1295 * f.quo(Rational(2, 1)) # => 1.57
1296 * f.quo(Complex(2, 0)) # => (1.57+0.0i)
1297 *
1298 */
1300 static VALUE
1302 {
1304 }
1306 static void
1308 {
1312 /* y is NaN so all results are NaN */
1316 }
1321 #ifdef HAVE_FMOD
1323 #else
1328 #endif
1329 }
1335 }
1339 }
1342 }
1344 /*
1345 * Returns the modulo of division of x by y.
1346 * An error will be raised if y == 0.
1347 */
1349 double
1351 {
1355 }
1357 /*
1358 * call-seq:
1359 * self % other -> float
1360 *
1361 * Returns +self+ modulo +other+ as a float.
1362 *
1363 * For float +f+ and real number +r+, these expressions are equivalent:
1364 *
1365 * f % r
1366 * f-r*(f/r).floor
1367 * f.divmod(r)[1]
1368 *
1369 * See Numeric#divmod.
1370 *
1371 * Examples:
1372 *
1373 * 10.0 % 2 # => 0.0
1374 * 10.0 % 3 # => 1.0
1375 * 10.0 % 4 # => 2.0
1376 *
1377 * 10.0 % -2 # => 0.0
1378 * 10.0 % -3 # => -2.0
1379 * 10.0 % -4 # => -2.0
1380 *
1381 * 10.0 % 4.0 # => 2.0
1382 * 10.0 % Rational(4, 1) # => 2.0
1383 *
1384 */
1386 static VALUE
1388 {
1393 }
1396 }
1399 }
1402 }
1404 }
1406 static VALUE
1408 {
1411 }
1413 }
1415 /*
1416 * call-seq:
1417 * divmod(other) -> array
1418 *
1419 * Returns a 2-element array <tt>[q, r]</tt>, where
1420 *
1421 * q = (self/other).floor # Quotient
1422 * r = self % other # Remainder
1423 *
1424 * Examples:
1425 *
1426 * 11.0.divmod(4) # => [2, 3.0]
1427 * 11.0.divmod(-4) # => [-3, -1.0]
1428 * -11.0.divmod(4) # => [-3, 1.0]
1429 * -11.0.divmod(-4) # => [2, -3.0]
1430 *
1431 * 12.0.divmod(4) # => [3, 0.0]
1432 * 12.0.divmod(-4) # => [-3, 0.0]
1433 * -12.0.divmod(4) # => [-3, -0.0]
1434 * -12.0.divmod(-4) # => [3, -0.0]
1435 *
1436 * 13.0.divmod(4.0) # => [3, 1.0]
1437 * 13.0.divmod(Rational(4, 1)) # => [3, 1.0]
1438 *
1439 */
1441 static VALUE
1443 {
1449 }
1452 }
1455 }
1458 }
1463 }
1465 /*
1466 * call-seq:
1467 * self ** other -> numeric
1468 *
1469 * Raises +self+ to the power of +other+:
1470 *
1471 * f = 3.14
1472 * f ** 2 # => 9.8596
1473 * f ** -2 # => 0.1014239928597509
1474 * f ** 2.1 # => 11.054834900588839
1475 * f ** Rational(2, 1) # => 9.8596
1476 * f ** Complex(2, 0) # => (9.8596+0i)
1477 *
1478 */
1480 VALUE
1482 {
1487 }
1491 }
1495 }
1501 }
1504 }
1506 }
1508 /*
1509 * call-seq:
1510 * eql?(other) -> true or false
1511 *
1512 * Returns +true+ if +self+ and +other+ are the same type and have equal values.
1513 *
1514 * Of the Core and Standard Library classes,
1515 * only Integer, Rational, and Complex use this implementation.
1516 *
1517 * Examples:
1518 *
1519 * 1.eql?(1) # => true
1520 * 1.eql?(1.0) # => false
1521 * 1.eql?(Rational(1, 1)) # => false
1522 * 1.eql?(Complex(1, 0)) # => false
1523 *
1524 * \Method +eql?+ is different from <tt>==</tt> in that +eql?+ requires matching types,
1525 * while <tt>==</tt> does not.
1526 *
1527 */
1529 static VALUE
1531 {
1536 }
1539 }
1541 /*
1542 * call-seq:
1543 * self <=> other -> zero or nil
1544 *
1545 * Returns zero if +self+ is the same as +other+, +nil+ otherwise.
1546 *
1547 * No subclass in the Ruby Core or Standard Library uses this implementation.
1548 *
1549 */
1551 static VALUE
1553 {
1556 }
1558 static VALUE
1560 {
1561 VALUE result;
1565 }
1567 /*
1568 * call-seq:
1569 * self == other -> true or false
1570 *
1571 * Returns +true+ if +other+ has the same value as +self+, +false+ otherwise:
1572 *
1573 * 2.0 == 2 # => true
1574 * 2.0 == 2.0 # => true
1575 * 2.0 == Rational(2, 1) # => true
1576 * 2.0 == Complex(2, 0) # => true
1577 *
1578 * <tt>Float::NAN == Float::NAN</tt> returns an implementation-dependent value.
1579 *
1580 * Related: Float#eql? (requires +other+ to be a \Float).
1581 *
1582 */
1584 VALUE
1586 {
1591 }
1594 #if MSC_VERSION_BEFORE(1300)
1596 #endif
1597 }
1600 }
1602 #if MSC_VERSION_BEFORE(1300)
1604 #endif
1606 }
1608 #define flo_eq rb_float_equal
1611 /*
1612 * call-seq:
1613 * hash -> integer
1614 *
1615 * Returns the integer hash value for +self+.
1616 *
1617 * See also Object#hash.
1618 */
1620 static VALUE
1622 {
1624 }
1626 static VALUE
1628 {
1630 }
1632 VALUE
1634 {
1640 }
1642 /*
1643 * call-seq:
1644 * self <=> other -> -1, 0, +1, or nil
1645 *
1646 * Returns a value that depends on the numeric relation
1647 * between +self+ and +other+:
1648 *
1649 * - -1, if +self+ is less than +other+.
1650 * - 0, if +self+ is equal to +other+.
1651 * - 1, if +self+ is greater than +other+.
1652 * - +nil+, if the two values are incommensurate.
1653 *
1654 * Examples:
1655 *
1656 * 2.0 <=> 2 # => 0
1657 * 2.0 <=> 2.0 # => 0
1658 * 2.0 <=> Rational(2, 1) # => 0
1659 * 2.0 <=> Complex(2, 0) # => 0
1660 * 2.0 <=> 1.9 # => 1
1661 * 2.0 <=> 2.1 # => -1
1662 * 2.0 <=> 'foo' # => nil
1663 *
1664 * This is the basis for the tests in the Comparable module.
1665 *
1666 * <tt>Float::NAN <=> Float::NAN</tt> returns an implementation-dependent value.
1667 *
1668 */
1670 static VALUE
1672 {
1674 VALUE i;
1683 }
1686 }
1693 }
1696 }
1698 }
1700 }
1702 int
1704 {
1706 }
1708 /*
1709 * call-seq:
1710 * self > other -> true or false
1711 *
1712 * Returns +true+ if +self+ is numerically greater than +other+:
1713 *
1714 * 2.0 > 1 # => true
1715 * 2.0 > 1.0 # => true
1716 * 2.0 > Rational(1, 2) # => true
1717 * 2.0 > 2.0 # => false
1718 *
1719 * <tt>Float::NAN > Float::NAN</tt> returns an implementation-dependent value.
1720 *
1721 */
1723 VALUE
1725 {
1734 }
1737 #if MSC_VERSION_BEFORE(1300)
1739 #endif
1740 }
1743 }
1744 #if MSC_VERSION_BEFORE(1300)
1746 #endif
1748 }
1750 /*
1751 * call-seq:
1752 * self >= other -> true or false
1753 *
1754 * Returns +true+ if +self+ is numerically greater than or equal to +other+:
1755 *
1756 * 2.0 >= 1 # => true
1757 * 2.0 >= 1.0 # => true
1758 * 2.0 >= Rational(1, 2) # => true
1759 * 2.0 >= 2.0 # => true
1760 * 2.0 >= 2.1 # => false
1761 *
1762 * <tt>Float::NAN >= Float::NAN</tt> returns an implementation-dependent value.
1763 *
1764 */
1766 static VALUE
1768 {
1777 }
1780 #if MSC_VERSION_BEFORE(1300)
1782 #endif
1783 }
1786 }
1787 #if MSC_VERSION_BEFORE(1300)
1789 #endif
1791 }
1793 /*
1794 * call-seq:
1795 * self < other -> true or false
1796 *
1797 * Returns +true+ if +self+ is numerically less than +other+:
1798 *
1799 * 2.0 < 3 # => true
1800 * 2.0 < 3.0 # => true
1801 * 2.0 < Rational(3, 1) # => true
1802 * 2.0 < 2.0 # => false
1803 *
1804 * <tt>Float::NAN < Float::NAN</tt> returns an implementation-dependent value.
1805 *
1806 */
1808 static VALUE
1810 {
1819 }
1822 #if MSC_VERSION_BEFORE(1300)
1824 #endif
1825 }
1828 }
1829 #if MSC_VERSION_BEFORE(1300)
1831 #endif
1833 }
1835 /*
1836 * call-seq:
1837 * self <= other -> true or false
1838 *
1839 * Returns +true+ if +self+ is numerically less than or equal to +other+:
1840 *
1841 * 2.0 <= 3 # => true
1842 * 2.0 <= 3.0 # => true
1843 * 2.0 <= Rational(3, 1) # => true
1844 * 2.0 <= 2.0 # => true
1845 * 2.0 <= 1.0 # => false
1846 *
1847 * <tt>Float::NAN <= Float::NAN</tt> returns an implementation-dependent value.
1848 *
1849 */
1851 static VALUE
1853 {
1862 }
1865 #if MSC_VERSION_BEFORE(1300)
1867 #endif
1868 }
1871 }
1872 #if MSC_VERSION_BEFORE(1300)
1874 #endif
1876 }
1878 /*
1879 * call-seq:
1880 * eql?(other) -> true or false
1881 *
1882 * Returns +true+ if +other+ is a \Float with the same value as +self+,
1883 * +false+ otherwise:
1884 *
1885 * 2.0.eql?(2.0) # => true
1886 * 2.0.eql?(1.0) # => false
1887 * 2.0.eql?(1) # => false
1888 * 2.0.eql?(Rational(2, 1)) # => false
1889 * 2.0.eql?(Complex(2, 0)) # => false
1890 *
1891 * <tt>Float::NAN.eql?(Float::NAN)</tt> returns an implementation-dependent value.
1892 *
1893 * Related: Float#== (performs type conversions).
1894 */
1896 VALUE
1898 {
1902 #if MSC_VERSION_BEFORE(1300)
1904 #endif
1906 }
1908 }
1910 #define flo_eql rb_float_eql
1912 VALUE
1914 {
1917 }
1919 /*
1920 * call-seq:
1921 * nan? -> true or false
1922 *
1923 * Returns +true+ if +self+ is a NaN, +false+ otherwise.
1924 *
1925 * f = -1.0 #=> -1.0
1926 * f.nan? #=> false
1927 * f = 0.0/0.0 #=> NaN
1928 * f.nan? #=> true
1929 */
1931 static VALUE
1933 {
1937 }
1939 /*
1940 * call-seq:
1941 * infinite? -> -1, 1, or nil
1942 *
1943 * Returns:
1944 *
1945 * - 1, if +self+ is <tt>Infinity</tt>.
1946 * - -1 if +self+ is <tt>-Infinity</tt>.
1947 * - +nil+, otherwise.
1948 *
1949 * Examples:
1950 *
1951 * f = 1.0/0.0 # => Infinity
1952 * f.infinite? # => 1
1953 * f = -1.0/0.0 # => -Infinity
1954 * f.infinite? # => -1
1955 * f = 1.0 # => 1.0
1956 * f.infinite? # => nil
1957 * f = 0.0/0.0 # => NaN
1958 * f.infinite? # => nil
1959 *
1960 */
1962 VALUE
1964 {
1969 }
1972 }
1974 /*
1975 * call-seq:
1976 * finite? -> true or false
1977 *
1978 * Returns +true+ if +self+ is not +Infinity+, +-Infinity+, or +NaN+,
1979 * +false+ otherwise:
1980 *
1981 * f = 2.0 # => 2.0
1982 * f.finite? # => true
1983 * f = 1.0/0.0 # => Infinity
1984 * f.finite? # => false
1985 * f = -1.0/0.0 # => -Infinity
1986 * f.finite? # => false
1987 * f = 0.0/0.0 # => NaN
1988 * f.finite? # => false
1989 *
1990 */
1992 VALUE
1994 {
1998 }
2000 static VALUE
2002 {
2007 }
2009 /*
2010 * call-seq:
2011 * next_float -> float
2012 *
2013 * Returns the next-larger representable \Float.
2014 *
2015 * These examples show the internally stored values (64-bit hexadecimal)
2016 * for each \Float +f+ and for the corresponding <tt>f.next_float</tt>:
2017 *
2018 * f = 0.0 # 0x0000000000000000
2019 * f.next_float # 0x0000000000000001
2020 *
2021 * f = 0.01 # 0x3f847ae147ae147b
2022 * f.next_float # 0x3f847ae147ae147c
2023 *
2024 * In the remaining examples here, the output is shown in the usual way
2025 * (result +to_s+):
2026 *
2027 * 0.01.next_float # => 0.010000000000000002
2028 * 1.0.next_float # => 1.0000000000000002
2029 * 100.0.next_float # => 100.00000000000001
2030 *
2031 * f = 0.01
2032 * (0..3).each_with_index {|i| printf "%2d %-20a %s\n", i, f, f.to_s; f = f.next_float }
2033 *
2034 * Output:
2035 *
2036 * 0 0x1.47ae147ae147bp-7 0.01
2037 * 1 0x1.47ae147ae147cp-7 0.010000000000000002
2038 * 2 0x1.47ae147ae147dp-7 0.010000000000000004
2039 * 3 0x1.47ae147ae147ep-7 0.010000000000000005
2040 *
2041 * f = 0.0; 100.times { f += 0.1 }
2042 * f # => 9.99999999999998 # should be 10.0 in the ideal world.
2043 * 10-f # => 1.9539925233402755e-14 # the floating point error.
2044 * 10.0.next_float-10 # => 1.7763568394002505e-15 # 1 ulp (unit in the last place).
2045 * (10-f)/(10.0.next_float-10) # => 11.0 # the error is 11 ulp.
2046 * (10-f)/(10*Float::EPSILON) # => 8.8 # approximation of the above.
2047 * "%a" % 10 # => "0x1.4p+3"
2048 * "%a" % f # => "0x1.3fffffffffff5p+3" # the last hex digit is 5. 16 - 5 = 11 ulp.
2049 *
2050 * Related: Float#prev_float
2051 *
2052 */
2053 static VALUE
2055 {
2057 }
2059 /*
2060 * call-seq:
2061 * float.prev_float -> float
2062 *
2063 * Returns the next-smaller representable \Float.
2064 *
2065 * These examples show the internally stored values (64-bit hexadecimal)
2066 * for each \Float +f+ and for the corresponding <tt>f.pev_float</tt>:
2067 *
2068 * f = 5e-324 # 0x0000000000000001
2069 * f.prev_float # 0x0000000000000000
2070 *
2071 * f = 0.01 # 0x3f847ae147ae147b
2072 * f.prev_float # 0x3f847ae147ae147a
2073 *
2074 * In the remaining examples here, the output is shown in the usual way
2075 * (result +to_s+):
2076 *
2077 * 0.01.prev_float # => 0.009999999999999998
2078 * 1.0.prev_float # => 0.9999999999999999
2079 * 100.0.prev_float # => 99.99999999999999
2080 *
2081 * f = 0.01
2082 * (0..3).each_with_index {|i| printf "%2d %-20a %s\n", i, f, f.to_s; f = f.prev_float }
2083 *
2084 * Output:
2085 *
2086 * 0 0x1.47ae147ae147bp-7 0.01
2087 * 1 0x1.47ae147ae147ap-7 0.009999999999999998
2088 * 2 0x1.47ae147ae1479p-7 0.009999999999999997
2089 * 3 0x1.47ae147ae1478p-7 0.009999999999999995
2090 *
2091 * Related: Float#next_float.
2092 *
2093 */
2094 static VALUE
2096 {
2098 }
2100 VALUE
2102 {
2107 }
2121 }
2126 }
2127 }
2129 static int
2131 {
2134 }
2136 }
2138 /*
2139 * :markup: markdown
2140 *
2141 * call-seq:
2142 * floor(ndigits = 0) -> float or integer
2143 *
2144 * Returns a float or integer that is a "floor" value for `self`,
2145 * as specified by `ndigits`,
2146 * which must be an
2147 * [integer-convertible object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
2148 *
2149 * When `self` is zero,
2150 * returns a zero value:
2151 * a float if `ndigits` is positive,
2152 * an integer otherwise:
2153 *
2154 * ```
2155 * f = 0.0 # => 0.0
2156 * f.floor(20) # => 0.0
2157 * f.floor(0) # => 0
2158 * f.floor(-20) # => 0
2159 * ```
2160 *
2161 * When `self` is non-zero and `ndigits` is positive, returns a float with `ndigits`
2162 * digits after the decimal point (as available):
2163 *
2164 * ```
2165 * f = 12345.6789
2166 * f.floor(1) # => 12345.6
2167 * f.floor(3) # => 12345.678
2168 * f.floor(30) # => 12345.6789
2169 * f = -12345.6789
2170 * f.floor(1) # => -12345.7
2171 * f.floor(3) # => -12345.679
2172 * f.floor(30) # => -12345.6789
2173 * ```
2174 *
2175 * When `self` is non-zero and `ndigits` is non-positive,
2176 * returns an integer value based on a computed granularity:
2177 *
2178 * - The granularity is `10 ** ndigits.abs`.
2179 * - The returned value is the largest multiple of the granularity
2180 * that is less than or equal to `self`.
2181 *
2182 * Examples with positive `self`:
2183 *
2184 * | ndigits | Granularity | 12345.6789.floor(ndigits) |
2185 * |--------:|------------:|--------------------------:|
2186 * | 0 | 1 | 12345 |
2187 * | -1 | 10 | 12340 |
2188 * | -2 | 100 | 12300 |
2189 * | -3 | 1000 | 12000 |
2190 * | -4 | 10000 | 10000 |
2191 * | -5 | 100000 | 0 |
2192 *
2193 * Examples with negative `self`:
2194 *
2195 * | ndigits | Granularity | -12345.6789.floor(ndigits) |
2196 * |--------:|------------:|---------------------------:|
2197 * | 0 | 1 | -12346 |
2198 * | -1 | 10 | -12350 |
2199 * | -2 | 100 | -12400 |
2200 * | -3 | 1000 | -13000 |
2201 * | -4 | 10000 | -20000 |
2202 * | -5 | 100000 | -100000 |
2203 * | -6 | 1000000 | -1000000 |
2204 *
2205 * Note that the limited precision of floating-point arithmetic
2206 * may lead to surprising results:
2207 *
2208 * ```
2209 * (0.3 / 0.1).floor # => 2 # Not 3, (because (0.3 / 0.1) # => 2.9999999999999996, not 3.0)
2210 * ```
2211 *
2212 * Related: Float#ceil.
2213 *
2214 */
2216 static VALUE
2218 {
2221 }
2223 /*
2224 * :markup: markdown
2225 *
2226 * call-seq:
2227 * ceil(ndigits = 0) -> float or integer
2228 *
2229 * Returns a numeric that is a "ceiling" value for `self`,
2230 * as specified by the given `ndigits`,
2231 * which must be an
2232 * [integer-convertible object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
2233 *
2234 * When `ndigits` is positive, returns a Float with `ndigits`
2235 * decimal digits after the decimal point
2236 * (as available, but no fewer than 1):
2237 *
2238 * ```
2239 * f = 12345.6789
2240 * f.ceil(1) # => 12345.7
2241 * f.ceil(3) # => 12345.679
2242 * f.ceil(30) # => 12345.6789
2243 * f = -12345.6789
2244 * f.ceil(1) # => -12345.6
2245 * f.ceil(3) # => -12345.678
2246 * f.ceil(30) # => -12345.6789
2247 * f = 0.0
2248 * f.ceil(1) # => 0.0
2249 * f.ceil(100) # => 0.0
2250 * ```
2251 *
2252 * When `ndigits` is non-positive,
2253 * returns an Integer based on a computed granularity:
2254 *
2255 * - The granularity is `10 ** ndigits.abs`.
2256 * - The returned value is the largest multiple of the granularity
2257 * that is less than or equal to `self`.
2258 *
2259 * Examples with positive `self`:
2260 *
2261 * | ndigits | Granularity | 12345.6789.ceil(ndigits) |
2262 * |--------:|------------:|-------------------------:|
2263 * | 0 | 1 | 12346 |
2264 * | -1 | 10 | 12350 |
2265 * | -2 | 100 | 12400 |
2266 * | -3 | 1000 | 13000 |
2267 * | -4 | 10000 | 20000 |
2268 * | -5 | 100000 | 100000 |
2269 *
2270 * Examples with negative `self`:
2271 *
2272 * | ndigits | Granularity | -12345.6789.ceil(ndigits) |
2273 * |--------:|------------:|--------------------------:|
2274 * | 0 | 1 | -12345 |
2275 * | -1 | 10 | -12340 |
2276 * | -2 | 100 | -12300 |
2277 * | -3 | 1000 | -12000 |
2278 * | -4 | 10000 | -10000 |
2279 * | -5 | 100000 | 0 |
2280 *
2281 * When `self` is zero and `ndigits` is non-positive,
2282 * returns Integer zero:
2283 *
2284 * ```
2285 * 0.0.ceil(0) # => 0
2286 * 0.0.ceil(-1) # => 0
2287 * 0.0.ceil(-2) # => 0
2288 * ```
2289 *
2290 * Note that the limited precision of floating-point arithmetic
2291 * may lead to surprising results:
2292 *
2293 * ```
2294 * (2.1 / 0.7).ceil #=> 4 # Not 3 (because 2.1 / 0.7 # => 3.0000000000000004, not 3.0)
2295 * ```
2296 *
2297 * Related: Float#floor.
2298 *
2299 */
2301 static VALUE
2303 {
2306 }
2308 VALUE
2310 {
2316 }
2326 }
2331 }
2332 }
2334 static int
2336 {
2338 /* If 10**N / 2 > num, then return 0 */
2339 /* We have log_256(10) > 0.415241 and log_256(1/2) = -0.125, so */
2342 }
2345 }
2348 }
2350 }
2352 static SIGNED_VALUE
2354 {
2358 }
2360 }
2362 static SIGNED_VALUE
2364 {
2366 }
2368 static SIGNED_VALUE
2370 {
2372 }
2374 static int
2376 {
2378 }
2380 static int
2382 {
2384 }
2386 static int
2388 {
2390 }
2392 /*
2393 * Assumes num is an \Integer, ndigits <= 0
2394 */
2395 static VALUE
2397 {
2402 }
2412 }
2414 /* then int_pow overflow */
2416 }
2424 }
2426 }
2428 static VALUE
2430 {
2439 }
2446 }
2447 }
2449 static VALUE
2451 {
2461 }
2466 else
2471 }
2472 }
2474 VALUE
2476 {
2477 VALUE f;
2478 VALUE m;
2490 }
2492 /* then int_pow overflow */
2494 }
2498 }
2501 }
2502 }
2504 /*
2505 * call-seq:
2506 * round(ndigits = 0, half: :up) -> integer or float
2507 *
2508 * Returns +self+ rounded to the nearest value with
2509 * a precision of +ndigits+ decimal digits.
2510 *
2511 * When +ndigits+ is non-negative, returns a float with +ndigits+
2512 * after the decimal point (as available):
2513 *
2514 * f = 12345.6789
2515 * f.round(1) # => 12345.7
2516 * f.round(3) # => 12345.679
2517 * f = -12345.6789
2518 * f.round(1) # => -12345.7
2519 * f.round(3) # => -12345.679
2520 *
2521 * When +ndigits+ is negative, returns an integer
2522 * with at least <tt>ndigits.abs</tt> trailing zeros:
2523 *
2524 * f = 12345.6789
2525 * f.round(0) # => 12346
2526 * f.round(-3) # => 12000
2527 * f = -12345.6789
2528 * f.round(0) # => -12346
2529 * f.round(-3) # => -12000
2530 *
2531 * If keyword argument +half+ is given,
2532 * and +self+ is equidistant from the two candidate values,
2533 * the rounding is according to the given +half+ value:
2534 *
2535 * - +:up+ or +nil+: round away from zero:
2536 *
2537 * 2.5.round(half: :up) # => 3
2538 * 3.5.round(half: :up) # => 4
2539 * (-2.5).round(half: :up) # => -3
2540 *
2541 * - +:down+: round toward zero:
2542 *
2543 * 2.5.round(half: :down) # => 2
2544 * 3.5.round(half: :down) # => 3
2545 * (-2.5).round(half: :down) # => -2
2546 *
2547 * - +:even+: round toward the candidate whose last nonzero digit is even:
2548 *
2549 * 2.5.round(half: :even) # => 2
2550 * 3.5.round(half: :even) # => 4
2551 * (-2.5).round(half: :even) # => -2
2552 *
2553 * Raises and exception if the value for +half+ is invalid.
2554 *
2555 * Related: Float#truncate.
2556 *
2557 */
2559 static VALUE
2561 {
2569 }
2574 }
2577 }
2581 }
2588 /* In this case, pow(10, ndigits) may not be accurate. */
2590 }
2594 }
2596 }
2598 static int
2600 {
2603 /* Let `exp` be such that `number` is written as:"0.#{digits}e#{exp}",
2604 i.e. such that 10 ** (exp - 1) <= |number| < 10 ** exp
2605 Recall that up to float_dig digits can be needed to represent a double,
2606 so if ndigits + exp >= float_dig, the intermediate value (number * 10 ** ndigits)
2607 will be an integer and thus the result is the original number.
2608 If ndigits + exp <= 0, the result is 0 or "1e#{exp}", so
2609 if ndigits + exp < 0, the result is 0.
2610 We have:
2611 2 ** (binexp-1) <= |number| < 2 ** binexp
2612 10 ** ((binexp-1)/log_2(10)) <= |number| < 10 ** (binexp/log_2(10))
2613 If binexp >= 0, and since log_2(10) = 3.322259:
2614 10 ** (binexp/4 - 1) < |number| < 10 ** (binexp/3)
2615 floor(binexp/4) <= exp <= ceil(binexp/3)
2616 If binexp <= 0, swap the /4 and the /3
2617 So if ndigits + floor(binexp/(4 or 3)) >= float_dig, the result is number
2618 If ndigits + ceil(binexp/(3 or 4)) < 0 the result is 0
2619 */
2622 }
2624 }
2626 static int
2628 {
2631 }
2633 }
2635 /*
2636 * call-seq:
2637 * to_i -> integer
2638 *
2639 * Returns +self+ truncated to an Integer.
2640 *
2641 * 1.2.to_i # => 1
2642 * (-1.2).to_i # => -1
2643 *
2644 * Note that the limited precision of floating-point arithmetic
2645 * may lead to surprising results:
2646 *
2647 * (0.3 / 0.1).to_i # => 2 (!)
2648 *
2649 */
2651 static VALUE
2653 {
2660 }
2662 /*
2663 * call-seq:
2664 * truncate(ndigits = 0) -> float or integer
2665 *
2666 * Returns +self+ truncated (toward zero) to
2667 * a precision of +ndigits+ decimal digits.
2668 *
2669 * When +ndigits+ is positive, returns a float with +ndigits+ digits
2670 * after the decimal point (as available):
2671 *
2672 * f = 12345.6789
2673 * f.truncate(1) # => 12345.6
2674 * f.truncate(3) # => 12345.678
2675 * f = -12345.6789
2676 * f.truncate(1) # => -12345.6
2677 * f.truncate(3) # => -12345.678
2678 *
2679 * When +ndigits+ is negative, returns an integer
2680 * with at least <tt>ndigits.abs</tt> trailing zeros:
2681 *
2682 * f = 12345.6789
2683 * f.truncate(0) # => 12345
2684 * f.truncate(-3) # => 12000
2685 * f = -12345.6789
2686 * f.truncate(0) # => -12345
2687 * f.truncate(-3) # => -12000
2688 *
2689 * Note that the limited precision of floating-point arithmetic
2690 * may lead to surprising results:
2691 *
2692 * (0.3 / 0.1).truncate #=> 2 (!)
2693 *
2694 * Related: Float#round.
2695 *
2696 */
2697 static VALUE
2699 {
2702 else
2704 }
2706 /*
2707 * call-seq:
2708 * floor(ndigits = 0) -> float or integer
2709 *
2710 * Returns the largest float or integer that is less than or equal to +self+,
2711 * as specified by the given `ndigits`,
2712 * which must be an
2713 * {integer-convertible object}[rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects].
2714 *
2715 * Equivalent to <tt>self.to_f.floor(ndigits)</tt>.
2716 *
2717 * Related: #ceil, Float#floor.
2718 */
2720 static VALUE
2722 {
2724 }
2726 /*
2727 * call-seq:
2728 * ceil(ndigits = 0) -> float or integer
2729 *
2730 * Returns the smallest float or integer that is greater than or equal to +self+,
2731 * as specified by the given `ndigits`,
2732 * which must be an
2733 * {integer-convertible object}[rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects].
2734 *
2735 * Equivalent to <tt>self.to_f.ceil(ndigits)</tt>.
2736 *
2737 * Related: #floor, Float#ceil.
2738 */
2740 static VALUE
2742 {
2744 }
2746 /*
2747 * call-seq:
2748 * round(digits = 0) -> integer or float
2749 *
2750 * Returns +self+ rounded to the nearest value with
2751 * a precision of +digits+ decimal digits.
2752 *
2753 * \Numeric implements this by converting +self+ to a Float and
2754 * invoking Float#round.
2755 */
2757 static VALUE
2759 {
2761 }
2763 /*
2764 * call-seq:
2765 * truncate(digits = 0) -> integer or float
2766 *
2767 * Returns +self+ truncated (toward zero) to
2768 * a precision of +digits+ decimal digits.
2769 *
2770 * \Numeric implements this by converting +self+ to a Float and
2771 * invoking Float#truncate.
2772 */
2774 static VALUE
2776 {
2778 }
2780 double
2782 {
2788 }
2791 }
2799 else
2804 n++;
2805 }
2808 n++;
2809 }
2810 }
2817 n++;
2818 }
2821 n++;
2822 }
2823 }
2825 }
2827 int
2829 {
2838 /* if unit is infinity, i*unit+beg is NaN */
2840 }
2845 }
2851 }
2852 }
2854 }
2856 }
2858 VALUE
2860 {
2867 }
2872 }
2874 delta--;
2875 }
2878 }
2880 }
2887 }
2889 VALUE result;
2894 }
2897 if (!excl || RTEST(rb_funcall(to, cmp, 1, rb_funcall(from, '+', 1, rb_funcall(result, '*', 1, step))))) {
2899 }
2901 }
2902 }
2904 static int
2906 {
2909 VALUE r;
2914 }
2918 }
2923 }
2925 }
2927 static int
2929 {
2930 VALUE hash;
2942 }
2946 }
2947 }
2950 }
2952 static int
2953 num_step_check_fix_args(int argc, VALUE *to, VALUE *step, VALUE by, int fix_nil, int allow_zero_step)
2954 {
2958 }
2960 /* compatibility */
2963 }
2964 }
2967 }
2970 }
2974 }
2976 }
2978 static int
2979 num_step_scan_args(int argc, const VALUE *argv, VALUE *to, VALUE *step, int fix_nil, int allow_zero_step)
2980 {
2984 }
2986 static VALUE
2988 {
2996 }
2998 /*
2999 * call-seq:
3000 * step(to = nil, by = 1) {|n| ... } -> self
3001 * step(to = nil, by = 1) -> enumerator
3002 * step(to = nil, by: 1) {|n| ... } -> self
3003 * step(to = nil, by: 1) -> enumerator
3004 * step(by: 1, to: ) {|n| ... } -> self
3005 * step(by: 1, to: ) -> enumerator
3006 * step(by: , to: nil) {|n| ... } -> self
3007 * step(by: , to: nil) -> enumerator
3008 *
3009 * Generates a sequence of numbers; with a block given, traverses the sequence.
3010 *
3011 * Of the Core and Standard Library classes,
3012 * Integer, Float, and Rational use this implementation.
3013 *
3014 * A quick example:
3015 *
3016 * squares = []
3017 * 1.step(by: 2, to: 10) {|i| squares.push(i*i) }
3018 * squares # => [1, 9, 25, 49, 81]
3019 *
3020 * The generated sequence:
3021 *
3022 * - Begins with +self+.
3023 * - Continues at intervals of +by+ (which may not be zero).
3024 * - Ends with the last number that is within or equal to +to+;
3025 * that is, less than or equal to +to+ if +by+ is positive,
3026 * greater than or equal to +to+ if +by+ is negative.
3027 * If +to+ is +nil+, the sequence is of infinite length.
3028 *
3029 * If a block is given, calls the block with each number in the sequence;
3030 * returns +self+. If no block is given, returns an Enumerator::ArithmeticSequence.
3031 *
3032 * <b>Keyword Arguments</b>
3033 *
3034 * With keyword arguments +by+ and +to+,
3035 * their values (or defaults) determine the step and limit:
3036 *
3037 * # Both keywords given.
3038 * squares = []
3039 * 4.step(by: 2, to: 10) {|i| squares.push(i*i) } # => 4
3040 * squares # => [16, 36, 64, 100]
3041 * cubes = []
3042 * 3.step(by: -1.5, to: -3) {|i| cubes.push(i*i*i) } # => 3
3043 * cubes # => [27.0, 3.375, 0.0, -3.375, -27.0]
3044 * squares = []
3045 * 1.2.step(by: 0.2, to: 2.0) {|f| squares.push(f*f) }
3046 * squares # => [1.44, 1.9599999999999997, 2.5600000000000005, 3.24, 4.0]
3047 *
3048 * squares = []
3049 * Rational(6/5).step(by: 0.2, to: 2.0) {|r| squares.push(r*r) }
3050 * squares # => [1.0, 1.44, 1.9599999999999997, 2.5600000000000005, 3.24, 4.0]
3051 *
3052 * # Only keyword to given.
3053 * squares = []
3054 * 4.step(to: 10) {|i| squares.push(i*i) } # => 4
3055 * squares # => [16, 25, 36, 49, 64, 81, 100]
3056 * # Only by given.
3057 *
3058 * # Only keyword by given
3059 * squares = []
3060 * 4.step(by:2) {|i| squares.push(i*i); break if i > 10 }
3061 * squares # => [16, 36, 64, 100, 144]
3062 *
3063 * # No block given.
3064 * e = 3.step(by: -1.5, to: -3) # => (3.step(by: -1.5, to: -3))
3065 * e.class # => Enumerator::ArithmeticSequence
3066 *
3067 * <b>Positional Arguments</b>
3068 *
3069 * With optional positional arguments +to+ and +by+,
3070 * their values (or defaults) determine the step and limit:
3071 *
3072 * squares = []
3073 * 4.step(10, 2) {|i| squares.push(i*i) } # => 4
3074 * squares # => [16, 36, 64, 100]
3075 * squares = []
3076 * 4.step(10) {|i| squares.push(i*i) }
3077 * squares # => [16, 25, 36, 49, 64, 81, 100]
3078 * squares = []
3079 * 4.step {|i| squares.push(i*i); break if i > 10 } # => nil
3080 * squares # => [16, 25, 36, 49, 64, 81, 100, 121]
3081 *
3082 * <b>Implementation Notes</b>
3083 *
3084 * If all the arguments are integers, the loop operates using an integer
3085 * counter.
3086 *
3087 * If any of the arguments are floating point numbers, all are converted
3088 * to floats, and the loop is executed
3089 * <i>floor(n + n*Float::EPSILON) + 1</i> times,
3090 * where <i>n = (limit - self)/step</i>.
3091 *
3092 */
3094 static VALUE
3096 {
3106 }
3109 }
3112 }
3117 }
3120 }
3125 }
3129 }
3139 }
3146 }
3150 }
3151 }
3152 }
3159 }
3165 }
3166 }
3168 }
3172 {
3179 }
3181 #define FLOAT_OUT_OF_RANGE(val, type) do { \
3182 char buf[24]; \
3184 out_of_range_float(&buf, (val))); \
3185 } while (0)
3187 #define LONG_MIN_MINUS_ONE ((double)LONG_MIN-1)
3188 #define LONG_MAX_PLUS_ONE (2*(double)(LONG_MAX/2+1))
3189 #define ULONG_MAX_PLUS_ONE (2*(double)(ULONG_MAX/2+1))
3190 #define LONG_MIN_MINUS_ONE_IS_LESS_THAN(n) \
3191 (LONG_MIN_MINUS_ONE == (double)LONG_MIN ? \
3192 LONG_MIN <= (n): \
3193 LONG_MIN_MINUS_ONE < (n))
3195 long
3197 {
3198 again:
3201 }
3209 }
3212 }
3213 }
3216 }
3220 }
3221 }
3223 static unsigned long
3225 {
3226 again:
3229 }
3236 }
3245 }
3248 }
3249 }
3251 {
3256 }
3257 }
3261 }
3262 }
3264 unsigned long
3266 {
3268 }
3270 void
3272 {
3275 }
3277 #if SIZEOF_INT < SIZEOF_LONG
3278 static void
3280 {
3283 }
3284 }
3286 static void
3288 {
3290 /* minus */
3293 }
3295 /* plus */
3298 }
3299 }
3301 long
3303 {
3308 }
3310 long
3312 {
3317 }
3319 unsigned long
3321 {
3327 }
3329 unsigned long
3331 {
3336 }
3341 }
3342 #else
3343 long
3345 {
3347 }
3349 long
3351 {
3353 }
3355 unsigned long
3357 {
3359 }
3361 unsigned long
3363 {
3365 }
3366 #endif
3369 static void
3371 {
3374 }
3376 static void
3378 {
3381 }
3382 }
3384 static void
3386 {
3388 /* minus */
3391 }
3393 /* plus */
3396 }
3397 }
3399 short
3401 {
3406 }
3408 short
3410 {
3415 }
3417 unsigned short
3419 {
3425 }
3427 unsigned short
3429 {
3434 }
3439 }
3441 VALUE
3443 {
3452 }
3454 #if HAVE_LONG_LONG
3456 #define LLONG_MIN_MINUS_ONE ((double)LLONG_MIN-1)
3457 #define LLONG_MAX_PLUS_ONE (2*(double)(LLONG_MAX/2+1))
3458 #define ULLONG_MAX_PLUS_ONE (2*(double)(ULLONG_MAX/2+1))
3459 #ifndef ULLONG_MAX
3460 #define ULLONG_MAX ((unsigned LONG_LONG)LLONG_MAX*2+1)
3461 #endif
3462 #define LLONG_MIN_MINUS_ONE_IS_LESS_THAN(n) \
3463 (LLONG_MIN_MINUS_ONE == (double)LLONG_MIN ? \
3464 LLONG_MIN <= (n): \
3465 LLONG_MIN_MINUS_ONE < (n))
3467 LONG_LONG
3469 {
3472 }
3480 }
3483 }
3484 }
3487 }
3490 }
3493 }
3497 }
3499 unsigned LONG_LONG
3501 {
3504 }
3507 }
3514 }
3517 }
3518 }
3521 }
3525 }
3526 }
3530 /********************************************************************
3531 *
3532 * Document-class: Integer
3533 *
3534 * An \Integer object represents an integer value.
3535 *
3536 * You can create an \Integer object explicitly with:
3537 *
3538 * - An {integer literal}[rdoc-ref:syntax/literals.rdoc@Integer+Literals].
3539 *
3540 * You can convert certain objects to Integers with:
3541 *
3542 * - \Method #Integer.
3543 *
3544 * An attempt to add a singleton method to an instance of this class
3545 * causes an exception to be raised.
3546 *
3547 * == What's Here
3548 *
3549 * First, what's elsewhere. \Class \Integer:
3550 *
3551 * - Inherits from
3552 * {class Numeric}[rdoc-ref:Numeric@What-27s+Here]
3553 * and {class Object}[rdoc-ref:Object@What-27s+Here].
3554 * - Includes {module Comparable}[rdoc-ref:Comparable@What-27s+Here].
3555 *
3556 * Here, class \Integer provides methods for:
3557 *
3558 * - {Querying}[rdoc-ref:Integer@Querying]
3559 * - {Comparing}[rdoc-ref:Integer@Comparing]
3560 * - {Converting}[rdoc-ref:Integer@Converting]
3561 * - {Other}[rdoc-ref:Integer@Other]
3562 *
3563 * === Querying
3564 *
3565 * - #allbits?: Returns whether all bits in +self+ are set.
3566 * - #anybits?: Returns whether any bits in +self+ are set.
3567 * - #nobits?: Returns whether no bits in +self+ are set.
3568 *
3569 * === Comparing
3570 *
3571 * - #<: Returns whether +self+ is less than the given value.
3572 * - #<=: Returns whether +self+ is less than or equal to the given value.
3573 * - #<=>: Returns a number indicating whether +self+ is less than, equal
3574 * to, or greater than the given value.
3575 * - #== (aliased as #===): Returns whether +self+ is equal to the given
3576 * value.
3577 * - #>: Returns whether +self+ is greater than the given value.
3578 * - #>=: Returns whether +self+ is greater than or equal to the given value.
3579 *
3580 * === Converting
3581 *
3582 * - ::sqrt: Returns the integer square root of the given value.
3583 * - ::try_convert: Returns the given value converted to an \Integer.
3584 * - #% (aliased as #modulo): Returns +self+ modulo the given value.
3585 * - #&: Returns the bitwise AND of +self+ and the given value.
3586 * - #*: Returns the product of +self+ and the given value.
3587 * - #**: Returns the value of +self+ raised to the power of the given value.
3588 * - #+: Returns the sum of +self+ and the given value.
3589 * - #-: Returns the difference of +self+ and the given value.
3590 * - #/: Returns the quotient of +self+ and the given value.
3591 * - #<<: Returns the value of +self+ after a leftward bit-shift.
3592 * - #>>: Returns the value of +self+ after a rightward bit-shift.
3593 * - #[]: Returns a slice of bits from +self+.
3594 * - #^: Returns the bitwise EXCLUSIVE OR of +self+ and the given value.
3595 * - #|: Returns the bitwise OR of +self+ and the given value.
3596 * - #ceil: Returns the smallest number greater than or equal to +self+.
3597 * - #chr: Returns a 1-character string containing the character
3598 * represented by the value of +self+.
3599 * - #digits: Returns an array of integers representing the base-radix digits
3600 * of +self+.
3601 * - #div: Returns the integer result of dividing +self+ by the given value.
3602 * - #divmod: Returns a 2-element array containing the quotient and remainder
3603 * results of dividing +self+ by the given value.
3604 * - #fdiv: Returns the Float result of dividing +self+ by the given value.
3605 * - #floor: Returns the greatest number smaller than or equal to +self+.
3606 * - #pow: Returns the modular exponentiation of +self+.
3607 * - #pred: Returns the integer predecessor of +self+.
3608 * - #remainder: Returns the remainder after dividing +self+ by the given value.
3609 * - #round: Returns +self+ rounded to the nearest value with the given precision.
3610 * - #succ (aliased as #next): Returns the integer successor of +self+.
3611 * - #to_f: Returns +self+ converted to a Float.
3612 * - #to_s (aliased as #inspect): Returns a string containing the place-value
3613 * representation of +self+ in the given radix.
3614 * - #truncate: Returns +self+ truncated to the given precision.
3615 *
3616 * === Other
3617 *
3618 * - #downto: Calls the given block with each integer value from +self+
3619 * down to the given value.
3620 * - #times: Calls the given block +self+ times with each integer
3621 * in <tt>(0..self-1)</tt>.
3622 * - #upto: Calls the given block with each integer value from +self+
3623 * up to the given value.
3624 *
3625 */
3627 VALUE
3629 {
3632 }
3636 }
3637 }
3639 static VALUE
3641 {
3644 }
3648 }
3649 }
3651 VALUE
3653 {
3655 }
3657 /*
3658 * call-seq:
3659 * allbits?(mask) -> true or false
3660 *
3661 * Returns +true+ if all bits that are set (=1) in +mask+
3662 * are also set in +self+; returns +false+ otherwise.
3663 *
3664 * Example values:
3665 *
3666 * 0b1010101 self
3667 * 0b1010100 mask
3668 * 0b1010100 self & mask
3669 * true self.allbits?(mask)
3670 *
3671 * 0b1010100 self
3672 * 0b1010101 mask
3673 * 0b1010100 self & mask
3674 * false self.allbits?(mask)
3675 *
3676 * Related: Integer#anybits?, Integer#nobits?.
3677 *
3678 */
3680 static VALUE
3682 {
3685 }
3687 /*
3688 * call-seq:
3689 * anybits?(mask) -> true or false
3690 *
3691 * Returns +true+ if any bit that is set (=1) in +mask+
3692 * is also set in +self+; returns +false+ otherwise.
3693 *
3694 * Example values:
3695 *
3696 * 0b10000010 self
3697 * 0b11111111 mask
3698 * 0b10000010 self & mask
3699 * true self.anybits?(mask)
3700 *
3701 * 0b00000000 self
3702 * 0b11111111 mask
3703 * 0b00000000 self & mask
3704 * false self.anybits?(mask)
3705 *
3706 * Related: Integer#allbits?, Integer#nobits?.
3707 *
3708 */
3710 static VALUE
3712 {
3715 }
3717 /*
3718 * call-seq:
3719 * nobits?(mask) -> true or false
3720 *
3721 * Returns +true+ if no bit that is set (=1) in +mask+
3722 * is also set in +self+; returns +false+ otherwise.
3723 *
3724 * Example values:
3725 *
3726 * 0b11110000 self
3727 * 0b00001111 mask
3728 * 0b00000000 self & mask
3729 * true self.nobits?(mask)
3730 *
3731 * 0b00000001 self
3732 * 0b11111111 mask
3733 * 0b00000001 self & mask
3734 * false self.nobits?(mask)
3735 *
3736 * Related: Integer#allbits?, Integer#anybits?.
3737 *
3738 */
3740 static VALUE
3742 {
3745 }
3747 /*
3748 * call-seq:
3749 * succ -> next_integer
3750 *
3751 * Returns the successor integer of +self+ (equivalent to <tt>self + 1</tt>):
3752 *
3753 * 1.succ #=> 2
3754 * -1.succ #=> 0
3755 *
3756 * Related: Integer#pred (predecessor value).
3757 */
3759 VALUE
3761 {
3765 }
3768 }
3770 }
3772 #define int_succ rb_int_succ
3774 /*
3775 * call-seq:
3776 * pred -> next_integer
3777 *
3778 * Returns the predecessor of +self+ (equivalent to <tt>self - 1</tt>):
3779 *
3780 * 1.pred #=> 0
3781 * -1.pred #=> -2
3782 *
3783 * Related: Integer#succ (successor value).
3784 *
3785 */
3787 static VALUE
3789 {
3793 }
3796 }
3798 }
3800 #define int_pred rb_int_pred
3802 VALUE
3804 {
3806 VALUE str;
3815 }
3820 }
3822 }
3824 /* call-seq:
3825 * chr -> string
3826 * chr(encoding) -> string
3827 *
3828 * Returns a 1-character string containing the character
3829 * represented by the value of +self+, according to the given +encoding+.
3830 *
3831 * 65.chr # => "A"
3832 * 0.chr # => "\x00"
3833 * 255.chr # => "\xFF"
3834 * string = 255.chr(Encoding::UTF_8)
3835 * string.encoding # => Encoding::UTF_8
3836 *
3837 * Raises an exception if +self+ is negative.
3838 *
3839 * Related: Integer#ord.
3840 *
3841 */
3843 static VALUE
3845 {
3851 }
3854 }
3857 }
3865 }
3867 }
3871 }
3874 }
3879 }
3882 decode:
3884 }
3886 /*
3887 * Fixnum
3888 */
3890 static VALUE
3892 {
3894 }
3896 VALUE
3898 {
3901 }
3905 }
3906 }
3908 VALUE
3910 {
3918 }
3919 #if SIZEOF_LONG < SIZEOF_VOIDP
3920 # if SIZEOF_VOIDP == SIZEOF_LONG_LONG
3924 }
3925 # else
3926 /* should do something like above code, but currently ruby does not know */
3927 /* such platforms */
3928 # endif
3929 #endif
3932 }
3936 }
3939 }
3945 }
3948 }
3952 VALUE
3954 {
3958 }
3960 }
3962 /*
3963 * call-seq:
3964 * to_s(base = 10) -> string
3965 *
3966 * Returns a string containing the place-value representation of +self+
3967 * in radix +base+ (in 2..36).
3968 *
3969 * 12345.to_s # => "12345"
3970 * 12345.to_s(2) # => "11000000111001"
3971 * 12345.to_s(8) # => "30071"
3972 * 12345.to_s(10) # => "12345"
3973 * 12345.to_s(16) # => "3039"
3974 * 12345.to_s(36) # => "9ix"
3975 * 78546939656932.to_s(36) # => "rubyrules"
3976 *
3977 * Raises an exception if +base+ is out of range.
3978 */
3980 VALUE
3982 {
3987 else
3990 }
3992 VALUE
3994 {
3997 }
4000 }
4003 }
4005 static VALUE
4007 {
4010 }
4013 }
4016 }
4019 }
4022 }
4023 }
4025 VALUE
4027 {
4029 }
4031 /*
4032 * call-seq:
4033 * self + numeric -> numeric_result
4034 *
4035 * Performs addition:
4036 *
4037 * 2 + 2 # => 4
4038 * -2 + 2 # => 0
4039 * -2 + -2 # => -4
4040 * 2 + 2.0 # => 4.0
4041 * 2 + Rational(2, 1) # => (4/1)
4042 * 2 + Complex(2, 0) # => (4+0i)
4043 *
4044 */
4046 VALUE
4048 {
4051 }
4054 }
4056 }
4058 static VALUE
4060 {
4063 }
4067 }
4070 }
4073 }
4074 }
4076 /*
4077 * call-seq:
4078 * self - numeric -> numeric_result
4079 *
4080 * Performs subtraction:
4081 *
4082 * 4 - 2 # => 2
4083 * -4 - 2 # => -6
4084 * -4 - -2 # => -2
4085 * 4 - 2.0 # => 2.0
4086 * 4 - Rational(2, 1) # => (2/1)
4087 * 4 - Complex(2, 0) # => (2+0i)
4088 *
4089 */
4091 VALUE
4093 {
4096 }
4099 }
4101 }
4104 #define SQRT_LONG_MAX HALF_LONG_MSB
4105 /*tests if N*N would overflow*/
4106 #define FIT_SQRT_LONG(n) (((n)<SQRT_LONG_MAX)&&((n)>=-SQRT_LONG_MAX))
4108 static VALUE
4110 {
4113 }
4118 }
4120 }
4123 }
4126 }
4129 }
4130 }
4132 /*
4133 * call-seq:
4134 * self * numeric -> numeric_result
4135 *
4136 * Performs multiplication:
4137 *
4138 * 4 * 2 # => 8
4139 * 4 * -2 # => -8
4140 * -4 * 2 # => -8
4141 * 4 * 2.0 # => 8.0
4142 * 4 * Rational(1, 3) # => (4/3)
4143 * 4 * Complex(2, 0) # => (8+0i)
4144 */
4146 VALUE
4148 {
4151 }
4154 }
4156 }
4158 static double
4160 {
4163 #if SIZEOF_LONG * CHAR_BIT > DBL_MANT_DIG
4166 }
4167 #endif
4169 }
4172 }
4175 }
4178 }
4179 }
4181 double
4183 {
4189 }
4190 }
4193 }
4196 }
4199 }
4200 }
4202 /*
4203 * call-seq:
4204 * fdiv(numeric) -> float
4205 *
4206 * Returns the Float result of dividing +self+ by +numeric+:
4207 *
4208 * 4.fdiv(2) # => 2.0
4209 * 4.fdiv(-2) # => -2.0
4210 * -4.fdiv(2) # => -2.0
4211 * 4.fdiv(2.0) # => 2.0
4212 * 4.fdiv(Rational(3, 4)) # => 5.333333333333333
4213 *
4214 * Raises an exception if +numeric+ cannot be converted to a Float.
4215 *
4216 */
4218 VALUE
4220 {
4223 }
4225 }
4227 static VALUE
4229 {
4233 }
4237 }
4242 }
4244 VALUE v;
4248 }
4249 }
4255 }
4256 }
4258 static VALUE
4260 {
4262 }
4264 /*
4265 * call-seq:
4266 * self / numeric -> numeric_result
4267 *
4268 * Performs division; for integer +numeric+, truncates the result to an integer:
4269 *
4270 * 4 / 3 # => 1
4271 * 4 / -3 # => -2
4272 * -4 / 3 # => -2
4273 * -4 / -3 # => 1
4274 *
4275 * For other +numeric+, returns non-integer result:
4276 *
4277 * 4 / 3.0 # => 1.3333333333333333
4278 * 4 / Rational(3, 1) # => (4/3)
4279 * 4 / Complex(3, 0) # => ((4/3)+0i)
4280 *
4281 */
4283 VALUE
4285 {
4288 }
4291 }
4293 }
4295 static VALUE
4297 {
4299 }
4301 /*
4302 * call-seq:
4303 * div(numeric) -> integer
4304 *
4305 * Performs integer division; returns the integer result of dividing +self+
4306 * by +numeric+:
4307 *
4308 * 4.div(3) # => 1
4309 * 4.div(-3) # => -2
4310 * -4.div(3) # => -2
4311 * -4.div(-3) # => 1
4312 * 4.div(3.0) # => 1
4313 * 4.div(Rational(3, 1)) # => 1
4314 *
4315 * Raises an exception if +numeric+ does not have method +div+.
4316 *
4317 */
4319 VALUE
4321 {
4324 }
4327 }
4329 }
4331 static VALUE
4333 {
4337 }
4341 }
4344 }
4347 }
4348 }
4350 /*
4351 * call-seq:
4352 * self % other -> real_number
4353 *
4354 * Returns +self+ modulo +other+ as a real number.
4355 *
4356 * For integer +n+ and real number +r+, these expressions are equivalent:
4357 *
4358 * n % r
4359 * n-r*(n/r).floor
4360 * n.divmod(r)[1]
4361 *
4362 * See Numeric#divmod.
4363 *
4364 * Examples:
4365 *
4366 * 10 % 2 # => 0
4367 * 10 % 3 # => 1
4368 * 10 % 4 # => 2
4369 *
4370 * 10 % -2 # => 0
4371 * 10 % -3 # => -2
4372 * 10 % -4 # => -2
4373 *
4374 * 10 % 3.0 # => 1.0
4375 * 10 % Rational(3, 1) # => (1/1)
4376 *
4377 */
4378 VALUE
4380 {
4383 }
4386 }
4388 }
4390 /*
4391 * call-seq:
4392 * remainder(other) -> real_number
4393 *
4394 * Returns the remainder after dividing +self+ by +other+.
4395 *
4396 * Examples:
4397 *
4398 * 11.remainder(4) # => 3
4399 * 11.remainder(-4) # => 3
4400 * -11.remainder(4) # => -3
4401 * -11.remainder(-4) # => -3
4402 *
4403 * 12.remainder(4) # => 0
4404 * 12.remainder(-4) # => 0
4405 * -12.remainder(4) # => 0
4406 * -12.remainder(-4) # => 0
4407 *
4408 * 13.remainder(4.0) # => 1.0
4409 * 13.remainder(Rational(4, 1)) # => (1/1)
4410 *
4411 */
4413 static VALUE
4415 {
4423 }
4426 }
4428 }
4431 }
4433 }
4435 static VALUE
4437 {
4443 }
4447 }
4449 {
4457 }
4458 }
4461 }
4462 }
4464 /*
4465 * call-seq:
4466 * divmod(other) -> array
4467 *
4468 * Returns a 2-element array <tt>[q, r]</tt>, where
4469 *
4470 * q = (self/other).floor # Quotient
4471 * r = self % other # Remainder
4472 *
4473 * Examples:
4474 *
4475 * 11.divmod(4) # => [2, 3]
4476 * 11.divmod(-4) # => [-3, -1]
4477 * -11.divmod(4) # => [-3, 1]
4478 * -11.divmod(-4) # => [2, -3]
4479 *
4480 * 12.divmod(4) # => [3, 0]
4481 * 12.divmod(-4) # => [-3, 0]
4482 * -12.divmod(4) # => [-3, 0]
4483 * -12.divmod(-4) # => [3, 0]
4484 *
4485 * 13.divmod(4.0) # => [3, 1.0]
4486 * 13.divmod(Rational(4, 1)) # => [3, (1/1)]
4487 *
4488 */
4489 VALUE
4491 {
4494 }
4497 }
4499 }
4501 /*
4502 * call-seq:
4503 * self ** numeric -> numeric_result
4504 *
4505 * Raises +self+ to the power of +numeric+:
4506 *
4507 * 2 ** 3 # => 8
4508 * 2 ** -3 # => (1/8)
4509 * -2 ** 3 # => -8
4510 * -2 ** -3 # => (-1/8)
4511 * 2 ** 3.3 # => 9.849155306759329
4512 * 2 ** Rational(3, 1) # => (8/1)
4513 * 2 ** Complex(3, 0) # => (8+0i)
4514 *
4515 */
4517 static VALUE
4519 {
4528 else
4535 }
4538 }
4539 {
4542 }
4544 }
4549 VALUE v;
4550 bignum:
4556 }
4558 VALUE
4560 {
4562 }
4564 static VALUE
4566 {
4570 }
4577 }
4580 }
4581 }
4582 }
4584 static VALUE
4586 {
4599 }
4607 }
4613 }
4618 }
4621 }
4622 }
4624 /*
4625 * call-seq:
4626 * self ** numeric -> numeric_result
4627 *
4628 * Raises +self+ to the power of +numeric+:
4629 *
4630 * 2 ** 3 # => 8
4631 * 2 ** -3 # => (1/8)
4632 * -2 ** 3 # => -8
4633 * -2 ** -3 # => (-1/8)
4634 * 2 ** 3.3 # => 9.849155306759329
4635 * 2 ** Rational(3, 1) # => (8/1)
4636 * 2 ** Complex(3, 0) # => (8+0i)
4637 *
4638 */
4639 VALUE
4641 {
4644 }
4647 }
4649 }
4651 VALUE
4653 {
4665 }
4667 }
4669 static VALUE
4671 {
4676 }
4679 }
4682 }
4683 }
4685 /*
4686 * call-seq:
4687 * self == other -> true or false
4688 *
4689 * Returns +true+ if +self+ is numerically equal to +other+; +false+ otherwise.
4690 *
4691 * 1 == 2 #=> false
4692 * 1 == 1.0 #=> true
4693 *
4694 * Related: Integer#eql? (requires +other+ to be an \Integer).
4695 */
4697 VALUE
4699 {
4702 }
4705 }
4707 }
4709 static VALUE
4711 {
4716 }
4722 }
4724 }
4727 }
4730 }
4731 }
4733 /*
4734 * call-seq:
4735 * self <=> other -> -1, 0, +1, or nil
4736 *
4737 * Returns:
4738 *
4739 * - -1, if +self+ is less than +other+.
4740 * - 0, if +self+ is equal to +other+.
4741 * - 1, if +self+ is greater then +other+.
4742 * - +nil+, if +self+ and +other+ are incomparable.
4743 *
4744 * Examples:
4745 *
4746 * 1 <=> 2 # => -1
4747 * 1 <=> 1 # => 0
4748 * 1 <=> 0 # => 1
4749 * 1 <=> 'foo' # => nil
4750 *
4751 * 1 <=> 1.0 # => 0
4752 * 1 <=> Rational(1, 1) # => 0
4753 * 1 <=> Complex(1, 0) # => 0
4754 *
4755 * This method is the basis for comparisons in module Comparable.
4756 *
4757 */
4759 VALUE
4761 {
4764 }
4767 }
4770 }
4771 }
4773 static VALUE
4775 {
4778 }
4781 }
4784 }
4787 }
4788 }
4790 /*
4791 * call-seq:
4792 * self > other -> true or false
4793 *
4794 * Returns +true+ if the value of +self+ is greater than that of +other+:
4795 *
4796 * 1 > 0 # => true
4797 * 1 > 1 # => false
4798 * 1 > 2 # => false
4799 * 1 > 0.5 # => true
4800 * 1 > Rational(1, 2) # => true
4801 *
4802 * Raises an exception if the comparison cannot be made.
4803 *
4804 */
4806 VALUE
4808 {
4811 }
4814 }
4816 }
4818 static VALUE
4820 {
4823 }
4826 }
4830 }
4833 }
4834 }
4836 /*
4837 * call-seq:
4838 * self >= real -> true or false
4839 *
4840 * Returns +true+ if the value of +self+ is greater than or equal to
4841 * that of +other+:
4842 *
4843 * 1 >= 0 # => true
4844 * 1 >= 1 # => true
4845 * 1 >= 2 # => false
4846 * 1 >= 0.5 # => true
4847 * 1 >= Rational(1, 2) # => true
4848 *
4849 * Raises an exception if the comparison cannot be made.
4850 *
4851 */
4853 VALUE
4855 {
4858 }
4861 }
4863 }
4865 static VALUE
4867 {
4870 }
4873 }
4876 }
4879 }
4880 }
4882 /*
4883 * call-seq:
4884 * self < other -> true or false
4885 *
4886 * Returns +true+ if the value of +self+ is less than that of +other+:
4887 *
4888 * 1 < 0 # => false
4889 * 1 < 1 # => false
4890 * 1 < 2 # => true
4891 * 1 < 0.5 # => false
4892 * 1 < Rational(1, 2) # => false
4893 *
4894 * Raises an exception if the comparison cannot be made.
4895 *
4896 */
4898 static VALUE
4900 {
4903 }
4906 }
4908 }
4910 static VALUE
4912 {
4915 }
4918 }
4922 }
4925 }
4926 }
4928 /*
4929 * call-seq:
4930 * self <= real -> true or false
4931 *
4932 * Returns +true+ if the value of +self+ is less than or equal to
4933 * that of +other+:
4934 *
4935 * 1 <= 0 # => false
4936 * 1 <= 1 # => true
4937 * 1 <= 2 # => true
4938 * 1 <= 0.5 # => false
4939 * 1 <= Rational(1, 2) # => false
4940 *
4941 * Raises an exception if the comparison cannot be made.
4942 *
4943 */
4945 static VALUE
4947 {
4950 }
4953 }
4955 }
4957 static VALUE
4959 {
4961 }
4963 VALUE
4965 {
4968 }
4971 }
4973 }
4975 static VALUE
4977 {
4982 }
4984 }
4986 VALUE
4988 {
4998 /* show the original object, not coerced object */
5000 }
5002 }
5004 static VALUE
5006 {
5010 }
5014 }
5017 }
5019 /*
5020 * call-seq:
5021 * self & other -> integer
5022 *
5023 * Bitwise AND; each bit in the result is 1 if both corresponding bits
5024 * in +self+ and +other+ are 1, 0 otherwise:
5025 *
5026 * "%04b" % (0b0101 & 0b0110) # => "0100"
5027 *
5028 * Raises an exception if +other+ is not an \Integer.
5029 *
5030 * Related: Integer#| (bitwise OR), Integer#^ (bitwise EXCLUSIVE OR).
5031 *
5032 */
5034 VALUE
5036 {
5039 }
5042 }
5044 }
5046 static VALUE
5048 {
5052 }
5056 }
5059 }
5061 /*
5062 * call-seq:
5063 * self | other -> integer
5064 *
5065 * Bitwise OR; each bit in the result is 1 if either corresponding bit
5066 * in +self+ or +other+ is 1, 0 otherwise:
5067 *
5068 * "%04b" % (0b0101 | 0b0110) # => "0111"
5069 *
5070 * Raises an exception if +other+ is not an \Integer.
5071 *
5072 * Related: Integer#& (bitwise AND), Integer#^ (bitwise EXCLUSIVE OR).
5073 *
5074 */
5076 static VALUE
5078 {
5081 }
5084 }
5086 }
5088 static VALUE
5090 {
5094 }
5098 }
5101 }
5103 /*
5104 * call-seq:
5105 * self ^ other -> integer
5106 *
5107 * Bitwise EXCLUSIVE OR; each bit in the result is 1 if the corresponding bits
5108 * in +self+ and +other+ are different, 0 otherwise:
5109 *
5110 * "%04b" % (0b0101 ^ 0b0110) # => "0011"
5111 *
5112 * Raises an exception if +other+ is not an \Integer.
5113 *
5114 * Related: Integer#& (bitwise AND), Integer#| (bitwise OR).
5115 *
5116 */
5118 static VALUE
5120 {
5123 }
5126 }
5128 }
5130 static VALUE
5132 {
5143 }
5145 static VALUE
5147 {
5151 }
5154 }
5156 /*
5157 * call-seq:
5158 * self << count -> integer
5159 *
5160 * Returns +self+ with bits shifted +count+ positions to the left,
5161 * or to the right if +count+ is negative:
5162 *
5163 * n = 0b11110000
5164 * "%08b" % (n << 1) # => "111100000"
5165 * "%08b" % (n << 3) # => "11110000000"
5166 * "%08b" % (n << -1) # => "01111000"
5167 * "%08b" % (n << -3) # => "00011110"
5168 *
5169 * Related: Integer#>>.
5170 *
5171 */
5173 VALUE
5175 {
5178 }
5181 }
5183 }
5185 static VALUE
5187 {
5199 }
5201 static VALUE
5203 {
5207 }
5210 }
5212 /*
5213 * call-seq:
5214 * self >> count -> integer
5215 *
5216 * Returns +self+ with bits shifted +count+ positions to the right,
5217 * or to the left if +count+ is negative:
5218 *
5219 * n = 0b11110000
5220 * "%08b" % (n >> 1) # => "01111000"
5221 * "%08b" % (n >> 3) # => "00011110"
5222 * "%08b" % (n >> -1) # => "111100000"
5223 * "%08b" % (n >> -3) # => "11110000000"
5224 *
5225 * Related: Integer#<<.
5226 *
5227 */
5229 VALUE
5231 {
5234 }
5237 }
5239 }
5241 VALUE
5243 {
5254 }
5255 }
5262 }
5266 }
5269 /* copied from "r_less" in range.c */
5270 /* compares _a_ and _b_ and returns:
5271 * < 0: a < b
5272 * = 0: a = b
5273 * > 0: a > b or non-comparable
5274 */
5275 static int
5277 {
5283 }
5285 static VALUE
5287 {
5289 }
5291 static VALUE
5293 {
5299 /* beginless range */
5305 }
5308 }
5309 }
5312 }
5313 }
5322 }
5328 }
5330 }
5332 one_bit:
5335 }
5338 }
5340 }
5342 static VALUE
5344 {
5349 }
5351 /*
5352 * call-seq:
5353 * self[offset] -> 0 or 1
5354 * self[offset, size] -> integer
5355 * self[range] -> integer
5356 *
5357 * Returns a slice of bits from +self+.
5358 *
5359 * With argument +offset+, returns the bit at the given offset,
5360 * where offset 0 refers to the least significant bit:
5361 *
5362 * n = 0b10 # => 2
5363 * n[0] # => 0
5364 * n[1] # => 1
5365 * n[2] # => 0
5366 * n[3] # => 0
5367 *
5368 * In principle, <code>n[i]</code> is equivalent to <code>(n >> i) & 1</code>.
5369 * Thus, negative index always returns zero:
5370 *
5371 * 255[-1] # => 0
5372 *
5373 * With arguments +offset+ and +size+, returns +size+ bits from +self+,
5374 * beginning at +offset+ and including bits of greater significance:
5375 *
5376 * n = 0b111000 # => 56
5377 * "%010b" % n[0, 10] # => "0000111000"
5378 * "%010b" % n[4, 10] # => "0000000011"
5379 *
5380 * With argument +range+, returns <tt>range.size</tt> bits from +self+,
5381 * beginning at <tt>range.begin</tt> and including bits of greater significance:
5382 *
5383 * n = 0b111000 # => 56
5384 * "%010b" % n[0..9] # => "0000111000"
5385 * "%010b" % n[4..9] # => "0000000011"
5386 *
5387 * Raises an exception if the slice cannot be constructed.
5388 */
5390 static VALUE
5392 {
5396 }
5400 }
5402 /*
5403 * call-seq:
5404 * to_f -> float
5405 *
5406 * Converts +self+ to a Float:
5407 *
5408 * 1.to_f # => 1.0
5409 * -1.to_f # => -1.0
5410 *
5411 * If the value of +self+ does not fit in a Float,
5412 * the result is infinity:
5413 *
5414 * (10**400).to_f # => Infinity
5415 * (-10**400).to_f # => -Infinity
5416 *
5417 */
5419 static VALUE
5421 {
5426 }
5429 }
5432 }
5435 }
5437 static VALUE
5439 {
5445 }
5447 VALUE
5449 {
5452 }
5455 }
5457 }
5459 static VALUE
5461 {
5463 }
5465 VALUE
5467 {
5470 }
5473 }
5475 }
5477 static VALUE
5479 {
5484 }
5486 VALUE
5488 {
5491 }
5494 }
5496 }
5498 static VALUE
5500 {
5501 VALUE digits;
5517 }
5521 }
5523 static VALUE
5525 {
5550 }
5552 }
5557 }
5569 }
5570 }
5573 }
5575 /*
5576 * call-seq:
5577 * digits(base = 10) -> array_of_integers
5578 *
5579 * Returns an array of integers representing the +base+-radix
5580 * digits of +self+;
5581 * the first element of the array represents the least significant digit:
5582 *
5583 * 12345.digits # => [5, 4, 3, 2, 1]
5584 * 12345.digits(7) # => [4, 6, 6, 0, 5]
5585 * 12345.digits(100) # => [45, 23, 1]
5586 *
5587 * Raises an exception if +self+ is negative or +base+ is less than 2.
5588 *
5589 */
5591 static VALUE
5593 {
5594 VALUE base_value;
5613 }
5614 else
5623 }
5625 static VALUE
5627 {
5629 }
5631 /*
5632 * call-seq:
5633 * upto(limit) {|i| ... } -> self
5634 * upto(limit) -> enumerator
5635 *
5636 * Calls the given block with each integer value from +self+ up to +limit+;
5637 * returns +self+:
5638 *
5639 * a = []
5640 * 5.upto(10) {|i| a << i } # => 5
5641 * a # => [5, 6, 7, 8, 9, 10]
5642 * a = []
5643 * -5.upto(0) {|i| a << i } # => -5
5644 * a # => [-5, -4, -3, -2, -1, 0]
5645 * 5.upto(4) {|i| fail 'Cannot happen' } # => 5
5646 *
5647 * With no block given, returns an Enumerator.
5648 *
5649 */
5651 static VALUE
5653 {
5661 }
5662 }
5669 }
5671 }
5673 }
5675 static VALUE
5677 {
5679 }
5681 /*
5682 * call-seq:
5683 * downto(limit) {|i| ... } -> self
5684 * downto(limit) -> enumerator
5685 *
5686 * Calls the given block with each integer value from +self+ down to +limit+;
5687 * returns +self+:
5688 *
5689 * a = []
5690 * 10.downto(5) {|i| a << i } # => 10
5691 * a # => [10, 9, 8, 7, 6, 5]
5692 * a = []
5693 * 0.downto(-5) {|i| a << i } # => 0
5694 * a # => [0, -1, -2, -3, -4, -5]
5695 * 4.downto(5) {|i| fail 'Cannot happen' } # => 4
5696 *
5697 * With no block given, returns an Enumerator.
5698 *
5699 */
5701 static VALUE
5703 {
5711 }
5712 }
5719 }
5721 }
5723 }
5725 static VALUE
5727 {
5729 }
5731 /*
5732 * call-seq:
5733 * round(ndigits= 0, half: :up) -> integer
5734 *
5735 * Returns +self+ rounded to the nearest value with
5736 * a precision of +ndigits+ decimal digits.
5737 *
5738 * When +ndigits+ is negative, the returned value
5739 * has at least <tt>ndigits.abs</tt> trailing zeros:
5740 *
5741 * 555.round(-1) # => 560
5742 * 555.round(-2) # => 600
5743 * 555.round(-3) # => 1000
5744 * -555.round(-2) # => -600
5745 * 555.round(-4) # => 0
5746 *
5747 * Returns +self+ when +ndigits+ is zero or positive.
5748 *
5749 * 555.round # => 555
5750 * 555.round(1) # => 555
5751 * 555.round(50) # => 555
5752 *
5753 * If keyword argument +half+ is given,
5754 * and +self+ is equidistant from the two candidate values,
5755 * the rounding is according to the given +half+ value:
5756 *
5757 * - +:up+ or +nil+: round away from zero:
5758 *
5759 * 25.round(-1, half: :up) # => 30
5760 * (-25).round(-1, half: :up) # => -30
5761 *
5762 * - +:down+: round toward zero:
5763 *
5764 * 25.round(-1, half: :down) # => 20
5765 * (-25).round(-1, half: :down) # => -20
5766 *
5767 *
5768 * - +:even+: round toward the candidate whose last nonzero digit is even:
5769 *
5770 * 25.round(-1, half: :even) # => 20
5771 * 15.round(-1, half: :even) # => 20
5772 * (-25).round(-1, half: :even) # => -20
5773 *
5774 * Raises and exception if the value for +half+ is invalid.
5775 *
5776 * Related: Integer#truncate.
5777 *
5778 */
5780 static VALUE
5782 {
5792 }
5794 }
5796 /*
5797 * :markup: markdown
5798 *
5799 * call-seq:
5800 * floor(ndigits = 0) -> integer
5801 *
5802 * Returns an integer that is a "floor" value for `self`,
5803 * as specified by the given `ndigits`,
5804 * which must be an
5805 * [integer-convertible object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
5806 *
5807 * - When `self` is zero, returns zero (regardless of the value of `ndigits`):
5808 *
5809 * ```
5810 * 0.floor(2) # => 0
5811 * 0.floor(-2) # => 0
5812 * ```
5813 *
5814 * - When `self` is non-zero and `ndigits` is non-negative, returns `self`:
5815 *
5816 * ```
5817 * 555.floor # => 555
5818 * 555.floor(50) # => 555
5819 * ```
5820 *
5821 * - When `self` is non-zero and `ndigits` is negative,
5822 * returns a value based on a computed granularity:
5823 *
5824 * - The granularity is `10 ** ndigits.abs`.
5825 * - The returned value is the largest multiple of the granularity
5826 * that is less than or equal to `self`.
5827 *
5828 * Examples with positive `self`:
5829 *
5830 * | ndigits | Granularity | 1234.floor(ndigits) |
5831 * |--------:|------------:|--------------------:|
5832 * | -1 | 10 | 1230 |
5833 * | -2 | 100 | 1200 |
5834 * | -3 | 1000 | 1000 |
5835 * | -4 | 10000 | 0 |
5836 * | -5 | 100000 | 0 |
5837 *
5838 * Examples with negative `self`:
5839 *
5840 * | ndigits | Granularity | -1234.floor(ndigits) |
5841 * |--------:|------------:|---------------------:|
5842 * | -1 | 10 | -1240 |
5843 * | -2 | 100 | -1300 |
5844 * | -3 | 1000 | -2000 |
5845 * | -4 | 10000 | -10000 |
5846 * | -5 | 100000 | -100000 |
5847 *
5848 * Related: Integer#ceil.
5849 *
5850 */
5852 static VALUE
5854 {
5861 }
5863 }
5865 /*
5866 * :markup: markdown
5867 *
5868 * call-seq:
5869 * ceil(ndigits = 0) -> integer
5870 *
5871 * Returns an integer that is a "ceiling" value for `self`,
5872 * as specified by the given `ndigits`,
5873 * which must be an
5874 * [integer-convertible object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
5875 *
5876 * - When `self` is zero, returns zero (regardless of the value of `ndigits`):
5877 *
5878 * ```
5879 * 0.ceil(2) # => 0
5880 * 0.ceil(-2) # => 0
5881 * ```
5882 *
5883 * - When `self` is non-zero and `ndigits` is non-negative, returns `self`:
5884 *
5885 * ```
5886 * 555.ceil # => 555
5887 * 555.ceil(50) # => 555
5888 * ```
5889 *
5890 * - When `self` is non-zero and `ndigits` is negative,
5891 * returns a value based on a computed granularity:
5892 *
5893 * - The granularity is `10 ** ndigits.abs`.
5894 * - The returned value is the smallest multiple of the granularity
5895 * that is greater than or equal to `self`.
5896 *
5897 * Examples with positive `self`:
5898 *
5899 * | ndigits | Granularity | 1234.ceil(ndigits) |
5900 * |--------:|------------:|-------------------:|
5901 * | -1 | 10 | 1240 |
5902 * | -2 | 100 | 1300 |
5903 * | -3 | 1000 | 2000 |
5904 * | -4 | 10000 | 10000 |
5905 * | -5 | 100000 | 100000 |
5906 *
5907 * Examples with negative `self`:
5908 *
5909 * | ndigits | Granularity | -1234.ceil(ndigits) |
5910 * |--------:|------------:|--------------------:|
5911 * | -1 | 10 | -1230 |
5912 * | -2 | 100 | -1200 |
5913 * | -3 | 1000 | -1000 |
5914 * | -4 | 10000 | 0 |
5915 * | -5 | 100000 | 0 |
5916 *
5917 * Related: Integer#floor.
5918 */
5920 static VALUE
5922 {
5929 }
5931 }
5933 /*
5934 * call-seq:
5935 * truncate(ndigits = 0) -> integer
5936 *
5937 * Returns +self+ truncated (toward zero) to
5938 * a precision of +ndigits+ decimal digits.
5939 *
5940 * When +ndigits+ is negative, the returned value
5941 * has at least <tt>ndigits.abs</tt> trailing zeros:
5942 *
5943 * 555.truncate(-1) # => 550
5944 * 555.truncate(-2) # => 500
5945 * -555.truncate(-2) # => -500
5946 *
5947 * Returns +self+ when +ndigits+ is zero or positive.
5948 *
5949 * 555.truncate # => 555
5950 * 555.truncate(50) # => 555
5951 *
5952 * Related: Integer#round.
5953 *
5954 */
5956 static VALUE
5958 {
5965 }
5967 }
5969 #define DEFINE_INT_SQRT(rettype, prefix, argtype) \
5970 rettype \
5971 prefix##_isqrt(argtype n) \
5972 { \
5973 if (!argtype##_IN_DOUBLE_P(n)) { \
5974 unsigned int b = bit_length(n); \
5975 argtype t; \
5976 rettype x = (rettype)(n >> (b/2+1)); \
5977 x |= ((rettype)1LU << (b-1)/2); \
5978 while ((t = n/x) < (argtype)x) x = (rettype)((x + t) >> 1); \
5979 return x; \
5980 } \
5981 return (rettype)sqrt(argtype##_TO_DOUBLE(n)); \
5982 }
5984 #if SIZEOF_LONG*CHAR_BIT > DBL_MANT_DIG
5985 # define RB_ULONG_IN_DOUBLE_P(n) ((n) < (1UL << DBL_MANT_DIG))
5986 #else
5987 # define RB_ULONG_IN_DOUBLE_P(n) 1
5988 #endif
5989 #define RB_ULONG_TO_DOUBLE(n) (double)(n)
5990 #define RB_ULONG unsigned long
5993 #if 2*SIZEOF_BDIGIT > SIZEOF_LONG
5994 # if 2*SIZEOF_BDIGIT*CHAR_BIT > DBL_MANT_DIG
5995 # define BDIGIT_DBL_IN_DOUBLE_P(n) ((n) < ((BDIGIT_DBL)1UL << DBL_MANT_DIG))
5996 # else
5997 # define BDIGIT_DBL_IN_DOUBLE_P(n) 1
5998 # endif
5999 # ifdef ULL_TO_DOUBLE
6000 # define BDIGIT_DBL_TO_DOUBLE(n) ULL_TO_DOUBLE(n)
6001 # else
6002 # define BDIGIT_DBL_TO_DOUBLE(n) (double)(n)
6003 # endif
6005 #endif
6007 #define domain_error(msg) \
6010 /*
6011 * call-seq:
6012 * Integer.sqrt(numeric) -> integer
6013 *
6014 * Returns the integer square root of the non-negative integer +n+,
6015 * which is the largest non-negative integer less than or equal to the
6016 * square root of +numeric+.
6017 *
6018 * Integer.sqrt(0) # => 0
6019 * Integer.sqrt(1) # => 1
6020 * Integer.sqrt(24) # => 4
6021 * Integer.sqrt(25) # => 5
6022 * Integer.sqrt(10**400) # => 10**200
6023 *
6024 * If +numeric+ is not an \Integer, it is converted to an \Integer:
6025 *
6026 * Integer.sqrt(Complex(4, 0)) # => 2
6027 * Integer.sqrt(Rational(4, 1)) # => 2
6028 * Integer.sqrt(4.0) # => 2
6029 * Integer.sqrt(3.14159) # => 1
6030 *
6031 * This method is equivalent to <tt>Math.sqrt(numeric).floor</tt>,
6032 * except that the result of the latter code may differ from the true value
6033 * due to the limited precision of floating point arithmetic.
6034 *
6035 * Integer.sqrt(10**46) # => 100000000000000000000000
6036 * Math.sqrt(10**46).floor # => 99999999999999991611392
6037 *
6038 * Raises an exception if +numeric+ is negative.
6039 *
6040 */
6042 static VALUE
6044 {
6050 }
6054 }
6059 }
6062 #if SIZEOF_BDIGIT <= SIZEOF_LONG
6063 /* short-circuit */
6068 }
6069 #endif
6071 }
6072 }
6074 /*
6075 * call-seq:
6076 * Integer.try_convert(object) -> object, integer, or nil
6077 *
6078 * If +object+ is an \Integer object, returns +object+.
6079 * Integer.try_convert(1) # => 1
6080 *
6081 * Otherwise if +object+ responds to <tt>:to_int</tt>,
6082 * calls <tt>object.to_int</tt> and returns the result.
6083 * Integer.try_convert(1.25) # => 1
6084 *
6085 * Returns +nil+ if +object+ does not respond to <tt>:to_int</tt>
6086 * Integer.try_convert([]) # => nil
6087 *
6088 * Raises an exception unless <tt>object.to_int</tt> returns an \Integer object.
6089 */
6090 static VALUE
6092 {
6094 }
6096 /*
6097 * Document-class: ZeroDivisionError
6098 *
6099 * Raised when attempting to divide an integer by 0.
6100 *
6101 * 42 / 0 #=> ZeroDivisionError: divided by 0
6102 *
6103 * Note that only division by an exact 0 will raise the exception:
6104 *
6105 * 42 / 0.0 #=> Float::INFINITY
6106 * 42 / -0.0 #=> -Float::INFINITY
6107 * 0 / 0.0 #=> NaN
6108 */
6110 /*
6111 * Document-class: FloatDomainError
6112 *
6113 * Raised when attempting to convert special float values (in particular
6114 * +Infinity+ or +NaN+) to numerical classes which don't support them.
6115 *
6116 * Float::INFINITY.to_r #=> FloatDomainError: Infinity
6117 */
6119 /*
6120 * Document-class: Numeric
6121 *
6122 * \Numeric is the class from which all higher-level numeric classes should inherit.
6123 *
6124 * \Numeric allows instantiation of heap-allocated objects. Other core numeric classes such as
6125 * Integer are implemented as immediates, which means that each Integer is a single immutable
6126 * object which is always passed by value.
6127 *
6128 * a = 1
6129 * 1.object_id == a.object_id #=> true
6130 *
6131 * There can only ever be one instance of the integer +1+, for example. Ruby ensures this
6132 * by preventing instantiation. If duplication is attempted, the same instance is returned.
6133 *
6134 * Integer.new(1) #=> NoMethodError: undefined method `new' for Integer:Class
6135 * 1.dup #=> 1
6136 * 1.object_id == 1.dup.object_id #=> true
6137 *
6138 * For this reason, \Numeric should be used when defining other numeric classes.
6139 *
6140 * Classes which inherit from \Numeric must implement +coerce+, which returns a two-member
6141 * Array containing an object that has been coerced into an instance of the new class
6142 * and +self+ (see #coerce).
6143 *
6144 * Inheriting classes should also implement arithmetic operator methods (<code>+</code>,
6145 * <code>-</code>, <code>*</code> and <code>/</code>) and the <code><=></code> operator (see
6146 * Comparable). These methods may rely on +coerce+ to ensure interoperability with
6147 * instances of other numeric classes.
6148 *
6149 * class Tally < Numeric
6150 * def initialize(string)
6151 * @string = string
6152 * end
6153 *
6154 * def to_s
6155 * @string
6156 * end
6157 *
6158 * def to_i
6159 * @string.size
6160 * end
6161 *
6162 * def coerce(other)
6163 * [self.class.new('|' * other.to_i), self]
6164 * end
6165 *
6166 * def <=>(other)
6167 * to_i <=> other.to_i
6168 * end
6169 *
6170 * def +(other)
6171 * self.class.new('|' * (to_i + other.to_i))
6172 * end
6173 *
6174 * def -(other)
6175 * self.class.new('|' * (to_i - other.to_i))
6176 * end
6177 *
6178 * def *(other)
6179 * self.class.new('|' * (to_i * other.to_i))
6180 * end
6181 *
6182 * def /(other)
6183 * self.class.new('|' * (to_i / other.to_i))
6184 * end
6185 * end
6186 *
6187 * tally = Tally.new('||')
6188 * puts tally * 2 #=> "||||"
6189 * puts tally > 1 #=> true
6190 *
6191 * == What's Here
6192 *
6193 * First, what's elsewhere. \Class \Numeric:
6194 *
6195 * - Inherits from {class Object}[rdoc-ref:Object@What-27s+Here].
6196 * - Includes {module Comparable}[rdoc-ref:Comparable@What-27s+Here].
6197 *
6198 * Here, class \Numeric provides methods for:
6199 *
6200 * - {Querying}[rdoc-ref:Numeric@Querying]
6201 * - {Comparing}[rdoc-ref:Numeric@Comparing]
6202 * - {Converting}[rdoc-ref:Numeric@Converting]
6203 * - {Other}[rdoc-ref:Numeric@Other]
6204 *
6205 * === Querying
6206 *
6207 * - #finite?: Returns true unless +self+ is infinite or not a number.
6208 * - #infinite?: Returns -1, +nil+ or +1, depending on whether +self+
6209 * is <tt>-Infinity<tt>, finite, or <tt>+Infinity</tt>.
6210 * - #integer?: Returns whether +self+ is an integer.
6211 * - #negative?: Returns whether +self+ is negative.
6212 * - #nonzero?: Returns whether +self+ is not zero.
6213 * - #positive?: Returns whether +self+ is positive.
6214 * - #real?: Returns whether +self+ is a real value.
6215 * - #zero?: Returns whether +self+ is zero.
6216 *
6217 * === Comparing
6218 *
6219 * - #<=>: Returns:
6220 *
6221 * - -1 if +self+ is less than the given value.
6222 * - 0 if +self+ is equal to the given value.
6223 * - 1 if +self+ is greater than the given value.
6224 * - +nil+ if +self+ and the given value are not comparable.
6225 *
6226 * - #eql?: Returns whether +self+ and the given value have the same value and type.
6227 *
6228 * === Converting
6229 *
6230 * - #% (aliased as #modulo): Returns the remainder of +self+ divided by the given value.
6231 * - #-@: Returns the value of +self+, negated.
6232 * - #abs (aliased as #magnitude): Returns the absolute value of +self+.
6233 * - #abs2: Returns the square of +self+.
6234 * - #angle (aliased as #arg and #phase): Returns 0 if +self+ is positive,
6235 * Math::PI otherwise.
6236 * - #ceil: Returns the smallest number greater than or equal to +self+,
6237 * to a given precision.
6238 * - #coerce: Returns array <tt>[coerced_self, coerced_other]</tt>
6239 * for the given other value.
6240 * - #conj (aliased as #conjugate): Returns the complex conjugate of +self+.
6241 * - #denominator: Returns the denominator (always positive)
6242 * of the Rational representation of +self+.
6243 * - #div: Returns the value of +self+ divided by the given value
6244 * and converted to an integer.
6245 * - #divmod: Returns array <tt>[quotient, modulus]</tt> resulting
6246 * from dividing +self+ the given divisor.
6247 * - #fdiv: Returns the Float result of dividing +self+ by the given divisor.
6248 * - #floor: Returns the largest number less than or equal to +self+,
6249 * to a given precision.
6250 * - #i: Returns the Complex object <tt>Complex(0, self)</tt>.
6251 * the given value.
6252 * - #imaginary (aliased as #imag): Returns the imaginary part of the +self+.
6253 * - #numerator: Returns the numerator of the Rational representation of +self+;
6254 * has the same sign as +self+.
6255 * - #polar: Returns the array <tt>[self.abs, self.arg]</tt>.
6256 * - #quo: Returns the value of +self+ divided by the given value.
6257 * - #real: Returns the real part of +self+.
6258 * - #rect (aliased as #rectangular): Returns the array <tt>[self, 0]</tt>.
6259 * - #remainder: Returns <tt>self-arg*(self/arg).truncate</tt> for the given +arg+.
6260 * - #round: Returns the value of +self+ rounded to the nearest value
6261 * for the given a precision.
6262 * - #to_c: Returns the Complex representation of +self+.
6263 * - #to_int: Returns the Integer representation of +self+, truncating if necessary.
6264 * - #truncate: Returns +self+ truncated (toward zero) to a given precision.
6265 *
6266 * === Other
6267 *
6268 * - #clone: Returns +self+; does not allow freezing.
6269 * - #dup (aliased as #+@): Returns +self+.
6270 * - #step: Invokes the given block with the sequence of specified numbers.
6271 *
6272 */
6273 void
6275 {
6276 #ifdef _UNICOSMP
6277 /* Turn off floating point exceptions for divide by zero, etc. */
6279 #endif
6373 #define fix_to_s_static(n) do { \
6374 VALUE lit = rb_fstring_literal(#n); \
6375 rb_fix_to_s_static[n] = lit; \
6376 rb_vm_register_global_object(lit); \
6377 RB_GC_GUARD(lit); \
6378 } while (0)
6391 #undef fix_to_s_static
6398 /*
6399 * The base of the floating point, or number of unique digits used to
6400 * represent the number.
6401 *
6402 * Usually defaults to 2 on most systems, which would represent a base-10 decimal.
6403 */
6405 /*
6406 * The number of base digits for the +double+ data type.
6407 *
6408 * Usually defaults to 53.
6409 */
6411 /*
6412 * The minimum number of significant decimal digits in a double-precision
6413 * floating point.
6414 *
6415 * Usually defaults to 15.
6416 */
6418 /*
6419 * The smallest possible exponent value in a double-precision floating
6420 * point.
6421 *
6422 * Usually defaults to -1021.
6423 */
6425 /*
6426 * The largest possible exponent value in a double-precision floating
6427 * point.
6428 *
6429 * Usually defaults to 1024.
6430 */
6432 /*
6433 * The smallest negative exponent in a double-precision floating point
6434 * where 10 raised to this power minus 1.
6435 *
6436 * Usually defaults to -307.
6437 */
6439 /*
6440 * The largest positive exponent in a double-precision floating point where
6441 * 10 raised to this power minus 1.
6442 *
6443 * Usually defaults to 308.
6444 */
6446 /*
6447 * The smallest positive normalized number in a double-precision floating point.
6448 *
6449 * Usually defaults to 2.2250738585072014e-308.
6450 *
6451 * If the platform supports denormalized numbers,
6452 * there are numbers between zero and Float::MIN.
6453 * 0.0.next_float returns the smallest positive floating point number
6454 * including denormalized numbers.
6455 */
6457 /*
6458 * The largest possible integer in a double-precision floating point number.
6459 *
6460 * Usually defaults to 1.7976931348623157e+308.
6461 */
6463 /*
6464 * The difference between 1 and the smallest double-precision floating
6465 * point number greater than 1.
6466 *
6467 * Usually defaults to 2.2204460492503131e-16.
6468 */
6470 /*
6471 * An expression representing positive infinity.
6472 */
6474 /*
6475 * An expression representing a value which is "not a number".
6476 */
6514 }
6516 #undef rb_float_value
6517 double
6519 {
6521 }
6523 #undef rb_float_new
6524 VALUE
6526 {
6528 }