# 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).

• :nodoc:.

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

 ``` 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909``` ```# File 'rational.c', line 882 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:

 ``` 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772``` ```# File 'rational.c', line 745 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:

 ``` 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813``` ```# File 'rational.c', line 786 static VALUE nurat_sub(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`.

 ``` 632 633 634 635 636 637 638 639``` ```# File 'rational.c', line 632 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
``````

 ``` 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960``` ```# File 'rational.c', line 924 static VALUE nurat_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)
 ``` 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143``` ```# File 'rational.c', line 1105 VALUE rb_rational_cmp(VALUE self, VALUE other) { if (RB_INTEGER_TYPE_P(other)) { { 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); goto other_is_rational; } } else if (RB_FLOAT_TYPE_P(other)) { return rb_dbl_cmp(nurat_to_double(self), RFLOAT_VALUE(other)); } else if (RB_TYPE_P(other, T_RATIONAL)) { other_is_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); } } else { 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)
 ``` 1157 1158 1159 1160 1161 1162 1163 1164 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 1195 1196``` ```# File 'rational.c', line 1157 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.

 ``` 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272``` ```# File 'rational.c', line 1263 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:

 ``` 1477 1478 1479 1480 1481``` ```# File 'rational.c', line 1477 static VALUE nurat_ceil_n(int argc, VALUE *argv, VALUE self) { return f_round_common(argc, argv, self, nurat_ceil); }```

### #coerce(other) ⇒ Object

:nodoc:

 ``` 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222``` ```# File 'rational.c', line 1199 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(f_rational_new_bang1 (CLASS_OF(self), RCOMPLEX(other)->real), self); else return rb_assoc_new(other, rb_Complex(self, INT2FIX(0))); } 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:

 ``` 619 620 621 622 623 624``` ```# File 'rational.c', line 619 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:

 ``` 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986``` ```# File 'rational.c', line 972 static VALUE nurat_fdiv(VALUE self, VALUE other) { VALUE div; if (f_zero_p(other)) return nurat_div(self, rb_float_new(0.0)); if (FIXNUM_P(other) && other == LONG2FIX(1)) return nurat_to_f(self); div = nurat_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:

 ``` 1447 1448 1449 1450 1451``` ```# File 'rational.c', line 1447 static VALUE nurat_floor_n(int argc, VALUE *argv, VALUE self) { return f_round_common(argc, argv, self, nurat_floor); }```

### #hash ⇒ Object

:nodoc:

 ``` 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767``` ```# File 'rational.c', line 1754 static VALUE nurat_hash(VALUE self) { st_index_t v, h[2]; VALUE n; get_dat1(self); n = rb_hash(dat->num); h[0] = NUM2LONG(n); n = rb_hash(dat->den); h[1] = NUM2LONG(n); v = rb_memhash(h, sizeof(h)); return ST2FIX(v); }```

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

 ``` 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272``` ```# File 'rational.c', line 1263 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)
 ``` 1243 1244 1245 1246 1247 1248``` ```# File 'rational.c', line 1243 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:

 ``` 601 602 603 604 605 606``` ```# File 'rational.c', line 601 static VALUE nurat_numerator(VALUE self) { get_dat1(self); return dat->num; }```

### #positive? ⇒ Boolean

Returns `true` if `rat` is greater than 0.

Returns:

• (Boolean)
 ``` 1230 1231 1232 1233 1234 1235``` ```# File 'rational.c', line 1230 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
``````

 ``` 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960``` ```# File 'rational.c', line 924 static VALUE nurat_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)
 ``` 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751``` ```# File 'rational.c', line 1731 static VALUE nurat_rationalize(int argc, VALUE *argv, VALUE self) { VALUE e, a, b, p, q; if (rb_check_arity(argc, 0, 1) == 0) return self; if (nurat_negative_p(self)) return rb_rational_uminus(nurat_rationalize(argc, argv, rb_rational_uminus(self))); e = f_abs(argv[0]); a = f_sub(self, e); b = f_add(self, e); if (f_eqeq_p(a, b)) return self; nurat_rationalize_internal(a, b, &p, &q); 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:

 ``` 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559``` ```# File 'rational.c', line 1550 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:

 ``` 1582 1583 1584 1585 1586``` ```# File 'rational.c', line 1582 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:

 ``` 1302 1303 1304 1305 1306 1307 1308 1309``` ```# File 'rational.c', line 1302 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)
 ``` 1597 1598 1599 1600 1601``` ```# File 'rational.c', line 1597 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:

 ``` 1507 1508 1509 1510 1511``` ```# File 'rational.c', line 1507 static VALUE nurat_truncate_n(int argc, VALUE *argv, VALUE self) { return f_round_common(argc, argv, self, nurat_truncate); }```