# Class: Rational

Inherits:
Numeric
show all
Defined in:
rational.c

## Overview

A rational number can be represented as a pair of integer numbers: a/b (b>0), where a is the numerator and b is the denominator. Integer a equals rational a/1 mathematically.

In Ruby, you can create rational objects with the Kernel#Rational, to_r, or rationalize methods or by suffixing r to a literal. The return values will be irreducible fractions.

Rational(1)      #=> (1/1)
Rational(2, 3)   #=> (2/3)
Rational(4, -6)  #=> (-2/3)
3.to_r           #=> (3/1)
2/3r             #=> (2/3)

You can also create rational objects from floating-point numbers or strings.

Rational(0.3)    #=> (5404319552844595/18014398509481984)
Rational('0.3')  #=> (3/10)
Rational('2/3')  #=> (2/3)

0.3.to_r         #=> (5404319552844595/18014398509481984)
'0.3'.to_r       #=> (3/10)
'2/3'.to_r       #=> (2/3)
0.3.rationalize  #=> (3/10)

A rational object is an exact number, which helps you to write programs without any rounding errors.

10.times.inject(0) {|t| t + 0.1 }              #=> 0.9999999999999999
10.times.inject(0) {|t| t + Rational('0.1') }  #=> (1/1)

However, when an expression includes an inexact component (numerical value or operation), it will produce an inexact result.

Rational(10) / 3   #=> (10/3)
Rational(10) / 3.0 #=> 3.3333333333333335

Rational(-8) ** Rational(1, 3)
#=> (1.0000000000000002+1.7320508075688772i)

## Defined Under Namespace

Classes: compatible

## Instance Method Summary collapse

• Performs multiplication.

• Performs subtraction.

• Negates rat.

• Performs division.

• Returns -1, 0, or +1 depending on whether rational is less than, equal to, or greater than numeric.

• Returns true if rat equals object numerically.

• Returns the absolute value of rat.

• Returns the smallest number greater than or equal to rat with a precision of ndigits decimal digits (default: 0).

• :nodoc:.

• Returns the denominator (always positive).

• Performs division and returns the value as a Float.

• Returns the largest number less than or equal to rat with a precision of ndigits decimal digits (default: 0).

• Returns the value as a string for inspection.

• Returns the absolute value of rat.

• private

:nodoc:.

• Returns true if rat is less than 0.

• Returns the numerator.

• Returns true if rat is greater than 0.

• Performs division.

• Returns a simpler approximation of the value if the optional argument eps is given (rat-|eps| <= result <= rat+|eps|), self otherwise.

• Returns rat rounded to the nearest value with a precision of ndigits decimal digits (default: 0).

• Returns the value as a Float.

• Returns the truncated value as an integer.

• Returns self.

• Returns the value as a string.

• Returns rat truncated (toward zero) to a precision of ndigits decimal digits (default: 0).

## Instance Method Details

### #*(numeric) ⇒ Numeric

Performs multiplication.

Rational(2, 3)  * Rational(2, 3)   #=> (4/9)
Rational(900)   * Rational(1)      #=> (900/1)
Rational(-2, 9) * Rational(-9, 2)  #=> (1/1)
Rational(9, 8)  * 4                #=> (9/2)
Rational(20, 9) * 9.8              #=> 21.77777777777778

Returns:

 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 # File 'rational.c', line 856 VALUE rb_rational_mul(VALUE self, VALUE other) { if (RB_INTEGER_TYPE_P(other)) { { get_dat1(self); return f_muldiv(self, dat->num, dat->den, other, ONE, '*'); } } else if (RB_FLOAT_TYPE_P(other)) { return DBL2NUM(nurat_to_double(self) * RFLOAT_VALUE(other)); } else if (RB_TYPE_P(other, T_RATIONAL)) { { get_dat2(self, other); return f_muldiv(self, adat->num, adat->den, bdat->num, bdat->den, '*'); } } else { return rb_num_coerce_bin(self, other, '*'); } }

### #+(numeric) ⇒ Numeric

Rational(2, 3)  + Rational(2, 3)   #=> (4/3)
Rational(900)   + Rational(1)      #=> (901/1)
Rational(-2, 9) + Rational(-9, 2)  #=> (-85/18)
Rational(9, 8)  + 4                #=> (41/8)
Rational(20, 9) + 9.8              #=> 12.022222222222222

Returns:

 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 # File 'rational.c', line 719 VALUE rb_rational_plus(VALUE self, VALUE other) { if (RB_INTEGER_TYPE_P(other)) { { get_dat1(self); return f_rational_new_no_reduce2(CLASS_OF(self), rb_int_plus(dat->num, rb_int_mul(other, dat->den)), dat->den); } } else if (RB_FLOAT_TYPE_P(other)) { return DBL2NUM(nurat_to_double(self) + RFLOAT_VALUE(other)); } else if (RB_TYPE_P(other, T_RATIONAL)) { { get_dat2(self, other); return f_addsub(self, adat->num, adat->den, bdat->num, bdat->den, '+'); } } else { return rb_num_coerce_bin(self, other, '+'); } }

### #-(numeric) ⇒ Numeric

Performs subtraction.

Rational(2, 3)  - Rational(2, 3)   #=> (0/1)
Rational(900)   - Rational(1)      #=> (899/1)
Rational(-2, 9) - Rational(-9, 2)  #=> (77/18)
Rational(9, 8)  - 4                #=> (-23/8)
Rational(20, 9) - 9.8              #=> -7.577777777777778

Returns:

 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 # File 'rational.c', line 760 VALUE rb_rational_minus(VALUE self, VALUE other) { if (RB_INTEGER_TYPE_P(other)) { { get_dat1(self); return f_rational_new_no_reduce2(CLASS_OF(self), rb_int_minus(dat->num, rb_int_mul(other, dat->den)), dat->den); } } else if (RB_FLOAT_TYPE_P(other)) { return DBL2NUM(nurat_to_double(self) - RFLOAT_VALUE(other)); } else if (RB_TYPE_P(other, T_RATIONAL)) { { get_dat2(self, other); return f_addsub(self, adat->num, adat->den, bdat->num, bdat->den, '-'); } } else { return rb_num_coerce_bin(self, other, '-'); } }

### #- ⇒ Object

Negates rat.

 606 607 608 609 610 611 612 613 # File 'rational.c', line 606 VALUE rb_rational_uminus(VALUE self) { const int unused = (assert(RB_TYPE_P(self, T_RATIONAL)), 0); get_dat1(self); (void)unused; return f_rational_new2(CLASS_OF(self), rb_int_uminus(dat->num), dat->den); }

### #/(numeric) ⇒ Numeric #quo(numeric) ⇒ Numeric

Performs division.

Rational(2, 3)  / Rational(2, 3)   #=> (1/1)
Rational(900)   / Rational(1)      #=> (900/1)
Rational(-2, 9) / Rational(-9, 2)  #=> (4/81)
Rational(9, 8)  / 4                #=> (9/32)
Rational(20, 9) / 9.8              #=> 0.22675736961451246

 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 # File 'rational.c', line 898 VALUE rb_rational_div(VALUE self, VALUE other) { if (RB_INTEGER_TYPE_P(other)) { if (f_zero_p(other)) rb_num_zerodiv(); { get_dat1(self); return f_muldiv(self, dat->num, dat->den, other, ONE, '/'); } } else if (RB_FLOAT_TYPE_P(other)) { VALUE v = nurat_to_f(self); return rb_flo_div_flo(v, other); } else if (RB_TYPE_P(other, T_RATIONAL)) { if (f_zero_p(other)) rb_num_zerodiv(); { get_dat2(self, other); if (f_one_p(self)) return f_rational_new_no_reduce2(CLASS_OF(self), bdat->den, bdat->num); return f_muldiv(self, adat->num, adat->den, bdat->num, bdat->den, '/'); } } else { return rb_num_coerce_bin(self, other, '/'); } }

### #<=>(numeric) ⇒ -1, ...

Returns -1, 0, or +1 depending on whether rational is less than, equal to, or greater than numeric.

nil is returned if the two values are incomparable.

Rational(2, 3) <=> Rational(2, 3)  #=> 0
Rational(5)    <=> 5               #=> 0
Rational(2, 3) <=> Rational(1, 3)  #=> 1
Rational(1, 3) <=> 1               #=> -1
Rational(1, 3) <=> 0.3             #=> 1

Rational(1, 3) <=> "0.3"           #=> nil

Returns:

• (-1, 0, +1, nil)
 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 # File 'rational.c', line 1070 VALUE rb_rational_cmp(VALUE self, VALUE other) { switch (TYPE(other)) { case T_FIXNUM: case T_BIGNUM: { get_dat1(self); if (dat->den == LONG2FIX(1)) return rb_int_cmp(dat->num, other); /* c14n */ other = f_rational_new_bang1(CLASS_OF(self), other); /* FALLTHROUGH */ } case T_RATIONAL: { VALUE num1, num2; get_dat2(self, other); if (FIXNUM_P(adat->num) && FIXNUM_P(adat->den) && FIXNUM_P(bdat->num) && FIXNUM_P(bdat->den)) { num1 = f_imul(FIX2LONG(adat->num), FIX2LONG(bdat->den)); num2 = f_imul(FIX2LONG(bdat->num), FIX2LONG(adat->den)); } else { num1 = rb_int_mul(adat->num, bdat->den); num2 = rb_int_mul(bdat->num, adat->den); } return rb_int_cmp(rb_int_minus(num1, num2), ZERO); } case T_FLOAT: return rb_dbl_cmp(nurat_to_double(self), RFLOAT_VALUE(other)); default: return rb_num_coerce_cmp(self, other, rb_intern("<=>")); } }

### #==(object) ⇒ Boolean

Returns true if rat equals object numerically.

Rational(2, 3)  == Rational(2, 3)   #=> true
Rational(5)     == 5                #=> true
Rational(0)     == 0.0              #=> true
Rational('1/3') == 0.33             #=> false
Rational('1/2') == '1/2'            #=> false

Returns:

• (Boolean)
 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 # File 'rational.c', line 1123 static VALUE nurat_eqeq_p(VALUE self, VALUE other) { if (RB_INTEGER_TYPE_P(other)) { get_dat1(self); if (RB_INTEGER_TYPE_P(dat->num) && RB_INTEGER_TYPE_P(dat->den)) { if (INT_ZERO_P(dat->num) && INT_ZERO_P(other)) return Qtrue; if (!FIXNUM_P(dat->den)) return Qfalse; if (FIX2LONG(dat->den) != 1) return Qfalse; return rb_int_equal(dat->num, other); } else { const double d = nurat_to_double(self); return f_boolcast(FIXNUM_ZERO_P(rb_dbl_cmp(d, NUM2DBL(other)))); } } else if (RB_FLOAT_TYPE_P(other)) { const double d = nurat_to_double(self); return f_boolcast(FIXNUM_ZERO_P(rb_dbl_cmp(d, RFLOAT_VALUE(other)))); } else if (RB_TYPE_P(other, T_RATIONAL)) { { get_dat2(self, other); if (INT_ZERO_P(adat->num) && INT_ZERO_P(bdat->num)) return Qtrue; return f_boolcast(rb_int_equal(adat->num, bdat->num) && rb_int_equal(adat->den, bdat->den)); } } else { return rb_equal(other, self); } }

### #abs ⇒ Object #magnitude ⇒ Object

Returns the absolute value of rat.

(1/2r).abs    #=> (1/2)
(-1/2r).abs   #=> (1/2)

Rational#magnitude is an alias for Rational#abs.

 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 # File 'rational.c', line 1235 VALUE rb_rational_abs(VALUE self) { get_dat1(self); if (INT_NEGATIVE_P(dat->num)) { VALUE num = rb_int_abs(dat->num); return nurat_s_canonicalize_internal_no_reduce(CLASS_OF(self), num, dat->den); } return self; }

### #ceil([ndigits]) ⇒ Integer

Returns the smallest number greater than or equal to rat with a precision of ndigits decimal digits (default: 0).

When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.

Returns a rational when ndigits is positive, otherwise returns an integer.

Rational(3).ceil      #=> 3
Rational(2, 3).ceil   #=> 1
Rational(-3, 2).ceil  #=> -1

#    decimal      -  1  2  3 . 4  5  6
#                   ^  ^  ^  ^   ^  ^
#   precision      -3 -2 -1  0  +1 +2

Rational('-123.456').ceil(+1).to_f  #=> -123.4
Rational('-123.456').ceil(-1)       #=> -120

Returns:

 1461 1462 1463 1464 1465 # File 'rational.c', line 1461 static VALUE nurat_ceil_n(int argc, VALUE *argv, VALUE self) { return f_round_common(argc, argv, self, nurat_ceil); }

### #coerce(other) ⇒ Object

:nodoc:

 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 # File 'rational.c', line 1165 static VALUE nurat_coerce(VALUE self, VALUE other) { if (RB_INTEGER_TYPE_P(other)) { return rb_assoc_new(f_rational_new_bang1(CLASS_OF(self), other), self); } else if (RB_FLOAT_TYPE_P(other)) { return rb_assoc_new(other, nurat_to_f(self)); } else if (RB_TYPE_P(other, T_RATIONAL)) { return rb_assoc_new(other, self); } else if (RB_TYPE_P(other, T_COMPLEX)) { if (!k_exact_zero_p(RCOMPLEX(other)->imag)) return rb_assoc_new(other, rb_Complex(self, INT2FIX(0))); other = RCOMPLEX(other)->real; if (RB_FLOAT_TYPE_P(other)) { other = float_to_r(other); RBASIC_SET_CLASS(other, CLASS_OF(self)); } else { other = f_rational_new_bang1(CLASS_OF(self), other); } return rb_assoc_new(other, self); } rb_raise(rb_eTypeError, "%s can't be coerced into %s", rb_obj_classname(other), rb_obj_classname(self)); return Qnil; }

### #denominator ⇒ Integer

Returns the denominator (always positive).

Rational(7).denominator             #=> 1
Rational(7, 1).denominator          #=> 1
Rational(9, -4).denominator         #=> 4
Rational(-2, -10).denominator       #=> 5

Returns:

 593 594 595 596 597 598 # File 'rational.c', line 593 static VALUE nurat_denominator(VALUE self) { get_dat1(self); return dat->den; }

### #fdiv(numeric) ⇒ Float

Performs division and returns the value as a Float.

Rational(2, 3).fdiv(1)       #=> 0.6666666666666666
Rational(2, 3).fdiv(0.5)     #=> 1.3333333333333333
Rational(2).fdiv(3)          #=> 0.6666666666666666

Returns:

 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 # File 'rational.c', line 946 static VALUE nurat_fdiv(VALUE self, VALUE other) { VALUE div; if (f_zero_p(other)) return rb_rational_div(self, rb_float_new(0.0)); if (FIXNUM_P(other) && other == LONG2FIX(1)) return nurat_to_f(self); div = rb_rational_div(self, other); if (RB_TYPE_P(div, T_RATIONAL)) return nurat_to_f(div); if (RB_FLOAT_TYPE_P(div)) return div; return rb_funcall(div, idTo_f, 0); }

### #floor([ndigits]) ⇒ Integer

Returns the largest number less than or equal to rat with a precision of ndigits decimal digits (default: 0).

When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.

Returns a rational when ndigits is positive, otherwise returns an integer.

Rational(3).floor      #=> 3
Rational(2, 3).floor   #=> 0
Rational(-3, 2).floor  #=> -2

#    decimal      -  1  2  3 . 4  5  6
#                   ^  ^  ^  ^   ^  ^
#   precision      -3 -2 -1  0  +1 +2

Rational('-123.456').floor(+1).to_f  #=> -123.5
Rational('-123.456').floor(-1)       #=> -130

Returns:

 1431 1432 1433 1434 1435 # File 'rational.c', line 1431 static VALUE nurat_floor_n(int argc, VALUE *argv, VALUE self) { return f_round_common(argc, argv, self, nurat_floor); }

### #hash ⇒ Object

 1762 1763 1764 1765 1766 # File 'rational.c', line 1762 static VALUE nurat_hash(VALUE self) { return ST2FIX(rb_rational_hash(self)); }

### #inspect ⇒ String

Returns the value as a string for inspection.

Rational(2).inspect      #=> "(2/1)"
Rational(-8, 6).inspect  #=> "(-4/3)"
Rational('1/2').inspect  #=> "(1/2)"

Returns:

 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 # File 'rational.c', line 1808 static VALUE nurat_inspect(VALUE self) { VALUE s; s = rb_usascii_str_new2("("); rb_str_concat(s, f_format(self, f_inspect)); rb_str_cat2(s, ")"); return s; }

### #abs ⇒ Object #magnitude ⇒ Object

Returns the absolute value of rat.

(1/2r).abs    #=> (1/2)
(-1/2r).abs   #=> (1/2)

Rational#magnitude is an alias for Rational#abs.

 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 # File 'rational.c', line 1235 VALUE rb_rational_abs(VALUE self) { get_dat1(self); if (INT_NEGATIVE_P(dat->num)) { VALUE num = rb_int_abs(dat->num); return nurat_s_canonicalize_internal_no_reduce(CLASS_OF(self), num, dat->den); } return self; }

### #marshal_dump ⇒ Object(private)

:nodoc:

 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 # File 'rational.c', line 1847 static VALUE nurat_marshal_dump(VALUE self) { VALUE a; get_dat1(self); a = rb_assoc_new(dat->num, dat->den); rb_copy_generic_ivar(a, self); return a; }

### #negative? ⇒ Boolean

Returns true if rat is less than 0.

Returns:

• (Boolean)
 1215 1216 1217 1218 1219 1220 # File 'rational.c', line 1215 static VALUE nurat_negative_p(VALUE self) { get_dat1(self); return f_boolcast(INT_NEGATIVE_P(dat->num)); }

### #numerator ⇒ Integer

Returns the numerator.

Rational(7).numerator        #=> 7
Rational(7, 1).numerator     #=> 7
Rational(9, -4).numerator    #=> -9
Rational(-2, -10).numerator  #=> 1

Returns:

 575 576 577 578 579 580 # File 'rational.c', line 575 static VALUE nurat_numerator(VALUE self) { get_dat1(self); return dat->num; }

### #positive? ⇒ Boolean

Returns true if rat is greater than 0.

Returns:

• (Boolean)
 1202 1203 1204 1205 1206 1207 # File 'rational.c', line 1202 static VALUE nurat_positive_p(VALUE self) { get_dat1(self); return f_boolcast(INT_POSITIVE_P(dat->num)); }

### #/(numeric) ⇒ Numeric #quo(numeric) ⇒ Numeric

Performs division.

Rational(2, 3)  / Rational(2, 3)   #=> (1/1)
Rational(900)   / Rational(1)      #=> (900/1)
Rational(-2, 9) / Rational(-9, 2)  #=> (4/81)
Rational(9, 8)  / 4                #=> (9/32)
Rational(20, 9) / 9.8              #=> 0.22675736961451246

 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 # File 'rational.c', line 898 VALUE rb_rational_div(VALUE self, VALUE other) { if (RB_INTEGER_TYPE_P(other)) { if (f_zero_p(other)) rb_num_zerodiv(); { get_dat1(self); return f_muldiv(self, dat->num, dat->den, other, ONE, '/'); } } else if (RB_FLOAT_TYPE_P(other)) { VALUE v = nurat_to_f(self); return rb_flo_div_flo(v, other); } else if (RB_TYPE_P(other, T_RATIONAL)) { if (f_zero_p(other)) rb_num_zerodiv(); { get_dat2(self, other); if (f_one_p(self)) return f_rational_new_no_reduce2(CLASS_OF(self), bdat->den, bdat->num); return f_muldiv(self, adat->num, adat->den, bdat->num, bdat->den, '/'); } } else { return rb_num_coerce_bin(self, other, '/'); } }

### #rationalize ⇒ self #rationalize(eps) ⇒ Object

Returns a simpler approximation of the value if the optional argument eps is given (rat-|eps| <= result <= rat+|eps|), self otherwise.

r = Rational(5033165, 16777216)
r.rationalize                    #=> (5033165/16777216)
r.rationalize(Rational('0.01'))  #=> (3/10)
r.rationalize(Rational('0.1'))   #=> (1/3)

• #rationalizeself

Returns:

• (self)
 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 # File 'rational.c', line 1715 static VALUE nurat_rationalize(int argc, VALUE *argv, VALUE self) { VALUE e, a, b, p, q; VALUE rat = self; get_dat1(self); if (rb_check_arity(argc, 0, 1) == 0) return self; e = f_abs(argv[0]); if (INT_NEGATIVE_P(dat->num)) { rat = f_rational_new2(RBASIC_CLASS(self), rb_int_uminus(dat->num), dat->den); } a = FIXNUM_ZERO_P(e) ? rat : rb_rational_minus(rat, e); b = FIXNUM_ZERO_P(e) ? rat : rb_rational_plus(rat, e); if (f_eqeq_p(a, b)) return self; nurat_rationalize_internal(a, b, &p, &q); if (rat != self) { RATIONAL_SET_NUM(rat, rb_int_uminus(p)); RATIONAL_SET_DEN(rat, q); return rat; } return f_rational_new2(CLASS_OF(self), p, q); }

### #round([ndigits][, half: mode]) ⇒ Integer

Returns rat rounded to the nearest value with a precision of ndigits decimal digits (default: 0).

When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.

Returns a rational when ndigits is positive, otherwise returns an integer.

Rational(3).round      #=> 3
Rational(2, 3).round   #=> 1
Rational(-3, 2).round  #=> -2

#    decimal      -  1  2  3 . 4  5  6
#                   ^  ^  ^  ^   ^  ^
#   precision      -3 -2 -1  0  +1 +2

Rational('-123.456').round(+1).to_f  #=> -123.5
Rational('-123.456').round(-1)       #=> -120

The optional half keyword argument is available similar to Float#round.

Rational(25, 100).round(1, half: :up)    #=> (3/10)
Rational(25, 100).round(1, half: :down)  #=> (1/5)
Rational(25, 100).round(1, half: :even)  #=> (1/5)
Rational(35, 100).round(1, half: :up)    #=> (2/5)
Rational(35, 100).round(1, half: :down)  #=> (3/10)
Rational(35, 100).round(1, half: :even)  #=> (2/5)
Rational(-25, 100).round(1, half: :up)   #=> (-3/10)
Rational(-25, 100).round(1, half: :down) #=> (-1/5)
Rational(-25, 100).round(1, half: :even) #=> (-1/5)

Returns:

 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 # File 'rational.c', line 1534 static VALUE nurat_round_n(int argc, VALUE *argv, VALUE self) { VALUE opt; enum ruby_num_rounding_mode mode = ( argc = rb_scan_args(argc, argv, "*:", NULL, &opt), rb_num_get_rounding_option(opt)); VALUE (*round_func)(VALUE) = ROUND_FUNC(mode, nurat_round); return f_round_common(argc, argv, self, round_func); }

### #to_f ⇒ Float

Returns the value as a Float.

Rational(2).to_f      #=> 2.0
Rational(9, 4).to_f   #=> 2.25
Rational(-3, 4).to_f  #=> -0.75
Rational(20, 3).to_f  #=> 6.666666666666667

Returns:

 1566 1567 1568 1569 1570 # File 'rational.c', line 1566 static VALUE nurat_to_f(VALUE self) { return DBL2NUM(nurat_to_double(self)); }

### #to_i ⇒ Integer

Returns the truncated value as an integer.

Equivalent to Rational#truncate.

Rational(2, 3).to_i    #=> 0
Rational(3).to_i       #=> 3
Rational(300.6).to_i   #=> 300
Rational(98, 71).to_i  #=> 1
Rational(-31, 2).to_i  #=> -15

Returns:

 1274 1275 1276 1277 1278 1279 1280 1281 # File 'rational.c', line 1274 static VALUE nurat_truncate(VALUE self) { get_dat1(self); if (INT_NEGATIVE_P(dat->num)) return rb_int_uminus(rb_int_idiv(rb_int_uminus(dat->num), dat->den)); return rb_int_idiv(dat->num, dat->den); }

### #to_r ⇒ self

Returns self.

Rational(2).to_r      #=> (2/1)
Rational(-8, 6).to_r  #=> (-4/3)

Returns:

• (self)
 1581 1582 1583 1584 1585 # File 'rational.c', line 1581 static VALUE nurat_to_r(VALUE self) { return self; }

### #to_s ⇒ String

Returns the value as a string.

Rational(2).to_s      #=> "2/1"
Rational(-8, 6).to_s  #=> "-4/3"
Rational('1/2').to_s  #=> "1/2"

Returns:

 1792 1793 1794 1795 1796 # File 'rational.c', line 1792 static VALUE nurat_to_s(VALUE self) { return f_format(self, f_to_s); }

### #truncate([ndigits]) ⇒ Integer

Returns rat truncated (toward zero) to a precision of ndigits decimal digits (default: 0).

When the precision is negative, the returned value is an integer with at least ndigits.abs trailing zeros.

Returns a rational when ndigits is positive, otherwise returns an integer.

Rational(3).truncate      #=> 3
Rational(2, 3).truncate   #=> 0
Rational(-3, 2).truncate  #=> -1

#    decimal      -  1  2  3 . 4  5  6
#                   ^  ^  ^  ^   ^  ^
#   precision      -3 -2 -1  0  +1 +2

Rational('-123.456').truncate(+1).to_f  #=> -123.4
Rational('-123.456').truncate(-1)       #=> -120

Returns:

 1491 1492 1493 1494 1495 # File 'rational.c', line 1491 static VALUE nurat_truncate_n(int argc, VALUE *argv, VALUE self) { return f_round_common(argc, argv, self, nurat_truncate); }