struct BigRational

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_rational"

r = BigRational.new(BigInt.new(7), BigInt.new(3))
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

Defined in:

big/big_rational.cr

Constructors

Instance Method Summary

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) <=>, ==(other : Complex) ==, abs abs, abs2 abs2, cis cis, clamp(min, max)
clamp(range : Range) clamp, divmod(number) divmod, i i, round(digits, 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::Builder) to_yaml, zero? : Bool zero?

Constructor methods inherited from struct Number

zero : self zero

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) ==, dup dup

Instance methods inherited from class Object

!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===, =~(other) =~, class class, dup dup, hash hash, inspect(io : IO)
inspect 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
to_s(io : IO) 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) : self from_yaml

Constructor Detail

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

Create a new BigRational.

If denominator is 0, this will raise an exception.


View source
def self.new(num : Int) #

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


View source

Instance Method Detail

def *(other : BigRational) #

View source
def *(other : Int) #

View source
def +(other : BigRational) #

View source
def +(other : Int) #

View source
def -(other : BigRational) #

View source
def -(other : Int) #

View source
def - #

View source
def /(other : Int) #

View source
def /(other : BigRational) #

View source
def <<(other : Int) #

Multiplies the rational by (2 ** other)

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

View source
def <=>(other : BigRational) #

View source
def <=>(other : Float) #

View source
def <=>(other : Int) #

View source
def >>(other : Int) #

Divides the rational by (2 ** other)

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

View source
def abs #

View source
def clone #

View source
def denominator #

View source
def hash #

View source
def inspect #

View source
def inspect(io) #

View source
def inv #

Returns a new BigRational as 1/r.

This will raise an exception if rational is 0.


View source
def numerator #

View source
def to_f #

Returns the Float64 representing this rational.


View source
def to_f32 #

View source
def to_f64 #

View source
def to_s(io : IO, base = 10) #

View source
def to_s(base = 10) #

Returns the string representing this rational.

Optionally takes a radix base (2 through 36).

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

View source
def to_unsafe #

View source