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

 ``` 855 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``` ```# File 'rational.c', line 855 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:

 ``` 718 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``` ```# File 'rational.c', line 718 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:

 ``` 759 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``` ```# File 'rational.c', line 759 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`.

 ``` 605 606 607 608 609 610 611 612``` ```# File 'rational.c', line 605 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
``````

 ``` 897 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``` ```# File 'rational.c', line 897 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)
 ``` 1069 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``` ```# File 'rational.c', line 1069 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)
 ``` 1122 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``` ```# File 'rational.c', line 1122 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.

 ``` 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237``` ```# File 'rational.c', line 1228 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:

 ``` 1454 1455 1456 1457 1458``` ```# File 'rational.c', line 1454 static VALUE nurat_ceil_n(int argc, VALUE *argv, VALUE self) { return f_round_common(argc, argv, self, nurat_ceil); }```

### #coerce(other) ⇒ Object

:nodoc:

 ``` 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187``` ```# File 'rational.c', line 1164 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:

 ``` 592 593 594 595 596 597``` ```# File 'rational.c', line 592 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:

 ``` 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959``` ```# File 'rational.c', line 945 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:

 ``` 1424 1425 1426 1427 1428``` ```# File 'rational.c', line 1424 static VALUE nurat_floor_n(int argc, VALUE *argv, VALUE self) { return f_round_common(argc, argv, self, nurat_floor); }```

### #hash ⇒ Object

:nodoc:

 ``` 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753``` ```# File 'rational.c', line 1740 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:

 ``` 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804``` ```# File 'rational.c', line 1794 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.

 ``` 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237``` ```# File 'rational.c', line 1228 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:

 ``` 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842``` ```# File 'rational.c', line 1833 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)
 ``` 1208 1209 1210 1211 1212 1213``` ```# File 'rational.c', line 1208 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:

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

### #positive? ⇒ Boolean

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

Returns:

• (Boolean)
 ``` 1195 1196 1197 1198 1199 1200``` ```# File 'rational.c', line 1195 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
``````

 ``` 897 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``` ```# File 'rational.c', line 897 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)
 ``` 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737``` ```# File 'rational.c', line 1708 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:

 ``` 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536``` ```# File 'rational.c', line 1527 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:

 ``` 1559 1560 1561 1562 1563``` ```# File 'rational.c', line 1559 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:

 ``` 1267 1268 1269 1270 1271 1272 1273 1274``` ```# File 'rational.c', line 1267 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)
 ``` 1574 1575 1576 1577 1578``` ```# File 'rational.c', line 1574 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:

 ``` 1778 1779 1780 1781 1782``` ```# File 'rational.c', line 1778 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:

 ``` 1484 1485 1486 1487 1488``` ```# File 'rational.c', line 1484 static VALUE nurat_truncate_n(int argc, VALUE *argv, VALUE self) { return f_round_common(argc, argv, self, nurat_truncate); }```