BigRational -

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

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

## Instance Method Summary

- #*(other : Int)
- #*(other : BigRational)
- #+(other : BigRational)
- #+(other : Int)
- #-(other : BigRational)
- #-(other : Int)
- #-
- #/(other : BigRational)
- #/(other : Int)
- #//(other)
- #<<(other : Int)

  Multiplies the rational by (2 ** other)

- #<=>(other : BigRational)
- #<=>(other : Float32 | Float64)
- #<=>(other : Float)
- #<=>(other : Int)
- #<=>(other : BigDecimal)
- #>>(other : Int)

  Divides the rational by (2 ** other)

- #abs
- #ceil
- #clone
- #denominator
- #floor
- #hash(hasher)

  TODO improve this

- #inspect : String
- #inspect(io : IO) : Nil
- #inv

  Returns a new `BigRational` as 1/r.

- #numerator
- #to_big_d

  Converts `self` to `BigDecimal`.

- #to_big_f
- #to_f

  Returns the `Float64` representing this rational.

- #to_f!
- #to_f32
- #to_f32!
- #to_f64
- #to_f64!
- #to_s(base : Int = 10) : String

  Returns the string representing this rational.

- #to_s(io : IO, base : Int = 10) : Nil
- #to_unsafe
- #trunc

### Instance methods inherited from module `Comparable(BigDecimal)`

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

### Instance methods inherited from module `Comparable(Float)`

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

### Instance methods inherited from module `Comparable(Int)`

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

### Instance methods inherited from module `Comparable(BigRational)`

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

### Instance methods inherited from struct `Number`

*(other : Complex)
*(other : BigFloat) *, +(other : BigFloat)
+(other : Complex)
+ +, -(other : Complex)
-(other : BigFloat) -, /(other : Complex)
/(other : BigFloat) /, //(other : BigFloat) //, <=>(other : BigFloat)
<=>(other) : Int32? <=>, ==(other : Complex) ==, abs abs, abs2 abs2, cis cis, clamp(min, max)
clamp(range : Range) clamp, divmod(number) divmod, format(io : IO, separator = '.', delimiter = ',', decimal_places : Int? = nil, *, group : Int = 3, only_significant : Bool = false) : Nil
format(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) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Proc) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &block) : String
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &prefixes : Int32, Float64 -> Tuple(Int32, UNDERSCORE) | Tuple(Int32, UNDERSCORE, Bool)) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes = SI_PREFIXES) : String
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Proc) : Nil humanize, i i, round(digits = 0, base = 10) round, sign sign, significant(digits, base = 10) significant, step(*, to = nil, by = 1)
step(*, to = nil, by = 1, &block) step, to_big_f to_big_f, to_c to_c, to_yaml(yaml : YAML::Nodes::Builder) to_yaml, zero? : Bool zero?

### Constructor methods inherited from struct `Number`

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) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

### Instance methods inherited from module `Comparable(Number)`

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

### Instance methods inherited from struct `Value`

==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==, dup dup

### Instance methods inherited from class `Object`

!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===, =~(other) =~, class class, dup dup, hash(hasher)
hash hash, inspect(io : IO) : Nil
inspect : String inspect, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json(io : IO)
to_json to_json, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json, to_s : String
to_s(io : IO) : Nil to_s, to_yaml(io : IO)
to_yaml to_yaml, try(&block) try, unsafe_as(type : T.class) forall T unsafe_as

### Constructor methods inherited from class `Object`

from_json(string_or_io, root : String) : self
from_json(string_or_io) : self from_json, from_yaml(string_or_io : String | IO) : self from_yaml

## Constructor Detail

def self.new(numerator : Int, denominator : Int) #

Creates a new `BigRational`.

If denominator is 0, this will raise an exception.

def self.new(num : Int) #

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

def self.new(num : Float) #

Creates a exact representation of float as rational.

## Instance Method Detail

def *(other : Int) #
def *(other : BigRational) #
def +(other : BigRational) #
def +(other : Int) #
def -(other : BigRational) #
def -(other : Int) #
def - #
def /(other : BigRational) #
def /(other : Int) #
def //(other) #
def <<(other : Int) #

Multiplies the rational by (2 ** other)

    require "big"

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

def <=>(other : BigRational) #
def <=>(other : Float32 | Float64) #
def <=>(other : Float) #
def <=>(other : Int) #
def <=>(other : BigDecimal) #
def >>(other : Int) #

Divides the rational by (2 ** other)

    require "big"

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

def abs #
def ceil #
def clone #
def denominator #
def floor #
def hash(hasher) #

TODO improve this

def inspect : String #
def inspect(io : IO) : Nil #
def inv #

Returns a new `BigRational` as 1/r.

This will raise an exception if rational is 0.

def numerator #
def to_big_d #

Converts `self` to `BigDecimal`.

def to_big_f #
def to_f #

Returns the `Float64` representing this rational.

def to_f! #
def to_f32 #
def to_f32! #
def to_f64 #
def to_f64! #
def to_s(base : Int = 10) : String #

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) : Nil #
def to_unsafe #
def trunc #