 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. 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:   big.cr    big/big_decimal.cr    big/big_rational.cr    big/number.cr     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) Creates a 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 : 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 : Int) : BigRational Multiplies the rational by (2 ** other)   #<=>(other : BigRational)   #<=>(other : Float32 | Float64)   #<=>(other : Float)   #<=>(other : Int)   #<=>(other : BigDecimal) The comparison operator.   #>>(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   #hash(hasher) TODO improve this   #inspect(io : IO) : Nil Appends a string representation of this object to the given IO object.   #inspect : String Returns a String representation of this object suitable to be embedded inside other expressions, sometimes providing more information about this object.   #inv : BigRational Returns a new BigRational as 1/r.   #numerator : BigInt   #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 Appends a String representation of this object to the given IO object.   #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    Instance methods inherited from module Comparable(BigDecimal)
  <(other : T) : Bool <,  <=(other : T) <=,  <=>(other : T) <=>,  ==(other : T) ==,  >(other : T) : Bool >,  >=(other : T) >=,  clamp(min, max)clamp(range : Range) clamp Instance methods inherited from module Comparable(Float)
  <(other : T) : Bool <,  <=(other : T) <=,  <=>(other : T) <=>,  ==(other : T) ==,  >(other : T) : Bool >,  >=(other : T) >=,  clamp(min, max)clamp(range : Range) clamp Instance methods inherited from module Comparable(Int)
  <(other : T) : Bool <,  <=(other : T) <=,  <=>(other : T) <=>,  ==(other : T) ==,  >(other : T) : Bool >,  >=(other : T) >=,  clamp(min, max)clamp(range : Range) clamp Instance methods inherited from module Comparable(BigRational)
  <(other : T) : Bool <,  <=(other : T) <=,  <=>(other : T) <=>,  ==(other : T) ==,  >(other : T) : Bool >,  >=(other : T) >=,  clamp(min, max)clamp(range : Range) clamp Instance methods inherited from struct Number
  *(other : BigFloat) : BigFloat*(other : Complex) : Complex *,  +(other : BigFloat)+(other : Complex) : Complex+ +,  -(other : BigFloat)-(other : Complex) : Complex -,  /(other : BigFloat) : BigFloat/(other : Complex) : Complex /,  //(other) //,  <=>(other : BigFloat)<=>(other) : Int32? <=>,  ==(other : Complex) ==,  abs : self abs,  abs2 abs2,  cis : Complex cis,  divmod(number) divmod,  format(io : IO, separator = '.', delimiter = ',', decimal_places : Int? = nil, *, group : Int = 3, only_significant : Bool = false) : Nilformat(separator = '.', delimiter = ',', decimal_places : Int? = nil, *, group : Int = 3, only_significant : Bool = false) : String format,  humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Indexable = SI_PREFIXES) : Nilhumanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Proc) : Nilhumanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes = SI_PREFIXES) : Stringhumanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &prefixes : Int32, Float64 -> Tuple(Int32, _) | Tuple(Int32, _, Bool)) : Nilhumanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &) : Stringhumanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Proc) : String humanize,  i : Complex i,  negative? : Bool negative?,  positive? : Bool positive?,  round(mode : RoundingMode = :ties_even) : selfround(digits : Number, base = 10, *, mode : RoundingMode = :ties_even) round,  sign : Int32 sign,  significant(digits, base = 10) significant,  step(*, to limit = nil, exclusive : Bool = false, &) : Nilstep(*, to limit = nil, exclusive : Bool = false) step,  to_big_f : BigFloat to_big_f,  to_c : Complex to_c,  to_yaml(yaml : YAML8b7c:f320:99b9:690f:4595:cd17:293a:c069Nodes8b7c:f320:99b9:690f:4595:cd17:293a:c069uilder) : Nil to_yaml,  zero? : Bool zero? Constructor methods inherited from struct Number
  additive_identity : self additive_identity,  multiplicative_identity : self multiplicative_identity,  zero : self zero Class methods inherited from struct Number
  si_prefix(magnitude : Int, prefixes = SI_PREFIXES) : Char? si_prefix Instance methods inherited from module Comparable(BigFloat)
  <(other : T) : Bool <,  <=(other : T) <=,  <=>(other : T) <=>,  ==(other : T) ==,  >(other : T) : Bool >,  >=(other : T) >=,  clamp(min, max)clamp(range : Range) clamp Instance methods inherited from module Steppable
  step(*, to limit = nil, by step, exclusive : Bool = false, &) : Nilstep(*, to limit = nil, by step, exclusive : Bool = false) step Instance methods inherited from module Comparable(Number)
  <(other : T) : Bool <,  <=(other : T) <=,  <=>(other : T) <=>,  ==(other : T) ==,  >(other : T) : Bool >,  >=(other : T) >=,  clamp(min, max)clamp(range : Range) clamp Instance methods inherited from struct Value
  ==(other : JSON8b7c:f320:99b9:690f:4595:cd17:293a:c069ny)==(other : YAML8b7c:f320:99b9:690f:4595:cd17:293a:c069ny)==(other) ==,  dup dup Instance methods inherited from class Object
  ! : Bool !,  !=(other) !=,  !~(other) !~,  ==(other) ==,  ===(other : JSON8b7c:f320:99b9:690f:4595:cd17:293a:c069ny)===(other : YAML8b7c:f320:99b9:690f:4595:cd17:293a:c069ny)===(other) ===,  =~(other) =~,  as(type : Class) as,  as?(type : Class) as?,  class class,  dup dup,  hash(hasher)hash hash,  in?(collection : Object) : Boolin?(*values : Object) : Bool in?,  inspect(io : IO) : Nilinspect : String inspect,  is_a?(type : Class) : Bool is_a?,  itself itself,  nil? : Bool nil?,  not_nil! not_nil!,  pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect,  pretty_print(pp : PrettyPrint) : Nil pretty_print,  responds_to?(name : Symbol) : Bool responds_to?,  tap(&) tap,  to_json(io : IO) : Nilto_json : String to_json,  to_pretty_json(indent : String = " ") : Stringto_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json,  to_s(io : IO) : Nilto_s : String to_s,  to_yaml(io : IO) : Nilto_yaml : String to_yaml,  try(&) try,  unsafe_as(type : T.class) forall T unsafe_as Class methods inherited from class Object
  from_json(string_or_io, root : String)from_json(string_or_io) from_json,  from_yaml(string_or_io : String | IO) from_yaml    Constructor Detail   def self.new(numerator : Int, denominator : Int)Source
  Creates a new BigRational. If denominator is 0, this will raise an exception.    def self.new(num : Int)Source
  Creates a new BigRational with num as the numerator and 1 for denominator.    def self.new(num : Float)Source
  Creates a exact representation of float as rational.    def self.new(num : BigRational)Source
  Creates a BigRational from the given num.    def self.new(num : BigDecimal)Source
  Creates a BigRational from the given num.     Instance Method Detail   def *(other : BigRational) : BigRationalSource
   def *(other : Int) : BigRationalSource
   def **(other : Int) : BigRationalSource
  Raises the rational to the otherth power This will raise DivisionByZeroError if rational is 0 and other is negative. require "big"

BigRational.new(2, 3) ** 2  # => 4/9
BigRational.new(2, 3) ** -1 # => 3/2    def +(other : BigRational) : BigRationalSource
   def +(other : Int) : BigRationalSource
   def -(other : BigRational) : BigRationalSource
   def -(other : Int) : BigRationalSource
   def - : BigRationalSource
   def /(other : BigRational) : BigRationalSource
   def /(other : BigInt) : BigRationalSource
   def /(other : BigFloat) : BigRationalSource
   def /(other : BigDecimal) : BigRationalSource
   def /(other : Int8) : BigRationalSource
   def /(other : UInt8) : BigRationalSource
   def /(other : Int16) : BigRationalSource
   def /(other : UInt16) : BigRationalSource
   def /(other : Int32) : BigRationalSource
   def /(other : UInt32) : BigRationalSource
   def /(other : Int64) : BigRationalSource
   def /(other : UInt64) : BigRationalSource
   def /(other : Int128) : BigRationalSource
   def /(other : UInt128) : BigRationalSource
   def /(other : Float32) : BigRationalSource
   def /(other : Float64) : BigRationalSource
   def <<(other : Int) : BigRationalSource
  Multiplies the rational by (2 ** other) require "big"

BigRational.new(2, 3) << 2 # => 8/3    def <=>(other : BigRational)Source
   def <=>(other : Float32 | Float64)Source
   def <=>(other : Float)Source
   def <=>(other : Int)Source
   def <=>(other : BigDecimal)Source
   Description copied from module Comparable(BigDecimal)  The comparison operator. Returns 0 if the two objects are equal, a negative number if this object is considered less than other, a positive number if this object is considered greater than other, or nil if the two objects are not comparable. Subclasses define this method to provide class-specific ordering. The comparison operator is usually used to sort values: # 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]    def >>(other : Int) : BigRationalSource
  Divides the rational by (2 ** other) require "big"

BigRational.new(2, 3) >> 2 # => 1/6    def abs : BigRationalSource
   Description copied from struct Number  Returns the absolute value of this number. 123.abs  # => 123
-123.abs # => 123    def ceil : BigRationalSource
   def cloneSource
   def denominator : BigIntSource
   def floor : BigRationalSource
   def hash(hasher)Source
  TODO improve this    def inspect(io : IO) : NilSource
   Description copied from class Object  Appends a string representation of this object to the given IO object. Similar to #to_s(io), but usually appends more information about this object. See #inspect.    def inspect : StringSource
   Description copied from class Object  Returns a String representation of this object suitable to be embedded inside other expressions, sometimes providing more information about this object. #inspect (and #inspect(io)) are the methods used when you invoke #to_s or #inspect on an object that holds other objects and wants to show them. For example when you invoke Array#to_s, #inspect will be invoked on each element: ary = ["one", "two", "three, etc."]
ary.inspect # => ["one", "two", "three, etc."] Note that if Array invoked #to_s on each of the elements above, the output would have been this: ary = ["one", "two", "three, etc."]
# If inspect invoked to_s on each element...
ary.inspect # => [one, two, three, etc.] Note that it's not clear how many elements the array has, or which are they, because #to_s doesn't guarantee that the string representation is clearly delimited (in the case of String the quotes are not shown). Also note that sometimes the output of #inspect will look like a Crystal expression that will compile, but this isn't always the case, nor is it necessary. Notably, Reference#inspect and Struct#inspect return values that don't compile. Classes must usually not override this method. Instead, they must override #inspect(io), which must append to the given IO object.    def inv : BigRationalSource
  Returns a new BigRational as 1/r. This will raise an exception if rational is 0.    def numerator : BigIntSource
   def to_big_d : BigDecimalSource
  Converts self to BigDecimal.    def to_big_f : BigFloatSource
   def to_big_i : BigIntSource
   def to_big_r : BigRationalSource
  Returns self. require "big"

BigRational.new(4, 5).to_big_r # => 4/5    def to_f : Float64Source
  Returns the Float64 representing this rational.    def to_f! : Float64Source
   def to_f32 : Float32Source
   def to_f32! : Float32Source
   def to_f64 : Float64Source
   def to_f64! : Float64Source
   def to_i16(*args, **options)Source
   def to_i16(*args, **options, &)Source
   def to_i32(*args, **options)Source
   def to_i32(*args, **options, &)Source
   def to_i64(*args, **options)Source
   def to_i64(*args, **options, &)Source
   def to_i8(*args, **options)Source
   def to_i8(*args, **options, &)Source
   def to_s(base : Int = 10) : StringSource
  Returns the string representing this rational. Optionally takes a radix base (2 through 36). require "big"

r = BigRational.new(8243243, 562828882)
r.to_s     # => "8243243/562828882"
r.to_s(16) # => "7dc82b/218c1652"
r.to_s(36) # => "4woiz/9b3djm"    def to_s(io : IO, base : Int = 10) : NilSource
   Description copied from class Object  Appends a String representation of this object to the given IO object. An object must never append itself to the io argument, as this will in turn call #to_s(io) on it.    def to_u16(*args, **options)Source
   def to_u16(*args, **options, &)Source
   def to_u32(*args, **options)Source
   def to_u32(*args, **options, &)Source
   def to_u64(*args, **options)Source
   def to_u64(*args, **options, &)Source
   def to_u8(*args, **options)Source
   def to_u8(*args, **options, &)Source
   def to_unsafeSource
   def trunc : BigRationalSource
 

    
{'path': 'public/docs/crystal/bigrational.html', 'source': 'DevDocs.IO'}