struct BigRational

• BigRational
• Number
• Value
• Object

Overview

Rational numbers are represented as the quotient of arbitrarily large numerators and denominators. Rationals are canonicalized such that the denominator and the numerator have no common factors, and that the denominator is positive. Zero has the unique representation 0/1.

NOTE To use BigRational, you must explicitly import it with require "big"

require "big"

r = BigRational.new(7.to_big_i, 3.to_big_i)
r.to_s # => "7/3"

r = BigRational.new(3, -9)
r.to_s # => "-1/3"

It is implemented under the hood with GMP.

Included Modules

• Comparable(BigDecimal)
• Comparable(Float)
• Comparable(Int)
• Comparable(BigRational)

Defined in:

Constructors

• .new(numerator : Int, denominator : Int)

  Creates a new BigRational.

• .new(num : Int)

  Creates a new BigRational with num as the numerator and 1 for denominator.

• .new(num : Float::Primitive)

  Creates an exact representation of float as rational.

• .new(num : BigFloat)

  Creates an exact representation of float as rational.

• .new(num : BigRational)

  Creates a BigRational from the given num.

• .new(num : BigDecimal)

  Creates a BigRational from the given num.

Instance Method Summary

• #%(other : BigRational) : BigRational
• #%(other : Int) : BigRational
• #*(other : BigRational) : BigRational
• #*(other : Int) : BigRational
• #**(other : Int) : BigRational

  Raises the rational to the otherth power

• #+(other : BigRational) : BigRational
• #+(other : Int) : BigRational
• #-(other : BigRational) : BigRational
• #-(other : Int) : BigRational
• #- : BigRational
• #/(other : BigRational) : BigRational
• #/(other : BigInt) : BigRational
• #/(other : BigFloat) : BigRational
• #/(other : BigDecimal) : BigRational
• #/(other : Int8) : BigRational
• #/(other : UInt8) : BigRational
• #/(other : Int16) : BigRational
• #/(other : UInt16) : BigRational
• #/(other : Int32) : BigRational
• #/(other : UInt32) : BigRational
• #/(other : Int64) : BigRational
• #/(other : UInt64) : BigRational
• #/(other : Int128) : BigRational
• #/(other : UInt128) : BigRational
• #/(other : Float32) : BigRational
• #/(other : Float64) : BigRational
• #//(other : BigRational) : BigRational
• #//(other : Int) : BigRational
• #<<(other : Int) : BigRational

  Multiplies the rational by (2 ** other)

• #<=>(other : BigRational)
• #<=>(other : Float::Primitive)
• #<=>(other : BigFloat)
• #<=>(other : BigInt)
• #<=>(other : Int)
• #<=>(other : BigDecimal)

  The comparison operator.

• #==(other : BigRational) : Bool
• #>>(other : Int) : BigRational

  Divides the rational by (2 ** other)

• #abs : BigRational

  Returns the absolute value of this number.

• #ceil : BigRational
• #clone
• #denominator : BigInt
• #floor : BigRational
• #format(io : IO, separator = '.', delimiter = ',', decimal_places : Int | Nil = nil, *, group : Int = 3, only_significant : Bool = false) : Nil

  Prints this number as a String using a customizable format.

• #inspect(io : IO) : Nil

  Prints to io an unambiguous and information-rich string representation of this object, typically intended for developers.

• #inspect : String

  Returns an unambiguous and information-rich string representation of this object, typically intended for developers.

• #integer? : Bool

  Returns true if self is an integer.

• #inv : BigRational

  Returns a new BigRational as 1/r.

• #numerator : BigInt
• #remainder(other : BigRational) : BigRational
• #remainder(other : Int) : BigRational
• #round_away : BigRational
• #round_even : BigRational
• #tdiv(other : BigRational) : BigRational
• #tdiv(other : Int) : BigRational
• #to_big_d : BigDecimal

  Converts self to BigDecimal.

• #to_big_f : BigFloat
• #to_big_i : BigInt
• #to_big_r : BigRational

  Returns self.

• #to_f : Float64

  Returns the Float64 representing this rational.

• #to_f! : Float64
• #to_f32 : Float32
• #to_f32! : Float32
• #to_f64 : Float64
• #to_f64! : Float64
• #to_i16(*args, **options)
• #to_i16(*args, **options, &)
• #to_i32(*args, **options)
• #to_i32(*args, **options, &)
• #to_i64(*args, **options)
• #to_i64(*args, **options, &)
• #to_i8(*args, **options)
• #to_i8(*args, **options, &)
• #to_s(base : Int = 10) : String

  Returns the string representing this rational.

• #to_s(io : IO, base : Int = 10) : Nil

  Prints a nicely readable and concise string representation of this object, typically intended for users, to io.

• #to_u16(*args, **options)
• #to_u16(*args, **options, &)
• #to_u32(*args, **options)
• #to_u32(*args, **options, &)
• #to_u64(*args, **options)
• #to_u64(*args, **options, &)
• #to_u8(*args, **options)
• #to_u8(*args, **options, &)
• #to_unsafe
• #trunc : BigRational

Constructor Detail

Instance Method Detail

require "big"

BigRational.new(2, 3) ** 2  # => 4/9
BigRational.new(2, 3) ** -1 # => 3/2

require "big"

BigRational.new(2, 3) << 2 # => 8/3

# Sort in a descending way:
[3, 1, 2].sort { |x, y| y <=> x } # => [3, 2, 1]

# Sort in an ascending way:
[3, 1, 2].sort { |x, y| x <=> y } # => [1, 2, 3]

require "big"

BigRational.new(2, 3) >> 2 # => 1/6

123.abs  # => 123
-123.abs # => 123

123_456.789.format                                            # => "123,456.789"
123_456.789.format(',', '.')                                  # => "123.456,789"
123_456.789.format(decimal_places: 2)                         # => "123,456.79"
123_456.789.format(decimal_places: 6)                         # => "123,456.789000"
123_456.789.format(decimal_places: 6, only_significant: true) # => "123,456.789"

1.integer?       # => true
1.0.integer?     # => true
1.2.integer?     # => false
(1 / 0).integer? # => false
(0 / 0).integer? # => false

require "big"

BigRational.new(4, 5).to_big_r # => 4/5

require "big"

r = BigRational.new(8243243, 562828882)
r.to_s     # => "8243243/562828882"
r.to_s(16) # => "7dc82b/218c1652"
r.to_s(36) # => "4woiz/9b3djm"

"foo #{bar} baz" # calls bar.to_io with the builder for this string

io << bar # calls bar.to_s(io)