W3cubDocs

/Crystal 0.31

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"

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

Defined in:

big.cr
big/big_rational.cr
big/big_decimal.cr
big/number.cr

Constructors

Instance Method Summary

Instance methods inherited from module Comparable(BigDecimal)

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

Instance methods inherited from module Comparable(Int)

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

Instance methods inherited from struct Number

*(other : Complex)
*(other : BigFloat) *
, +(other : BigFloat)
+(other : Complex)
+ +
, -(other : Complex)
-(other : BigFloat) -
, /(other : Complex)
/(other : BigFloat) /
, //(other) //, <=>(other : BigFloat)
<=>(other) : Int32? <=>
, ==(other : Complex) ==, abs abs, abs2 abs2, cis cis, clamp(range : Range)
clamp(min, max) clamp
, divmod(number) divmod, format(separator = '.', delimiter = ',', decimal_places : Int? = nil, *, group : Int = 3, only_significant : Bool = false) : String
format(io : IO, separator = '.', delimiter = ',', decimal_places : Int? = nil, *, group : Int = 3, only_significant : Bool = false) : Nil format
, humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Indexable = SI_PREFIXES) : Nil
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Proc) : 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 : Int32, Float64 -> Tuple(Int32, UNDERSCORE) | Tuple(Int32, UNDERSCORE, Bool)) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &block) : String
humanize(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) >=

Instance methods inherited from module Comparable(Number)

<, <=(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)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 : Int)Source

def *(other : BigRational)Source

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 : Int)Source

def +(other : BigRational)Source

def -Source

def -(other : Int)Source

def -(other : BigRational)Source

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 : UInt32) : BigRationalSource

def /(other : Int32) : BigRationalSource

def /(other : UInt16) : BigRationalSource

def /(other : Int16) : BigRationalSource

def /(other : UInt8) : BigRationalSource

def /(other : Int8) : BigRationalSource

def /(other : BigDecimal) : BigRationalSource

def /(other : BigFloat) : BigRationalSource

def /(other : BigInt) : BigRationalSource

def /(other : BigRational)Source

def <<(other : Int)Source

Multiplies the rational by (2 ** other)

require "big"

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

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 greter 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)Source

def <=>(other : Float)Source

def <=>(other : Float32 | Float64)Source

def <=>(other : BigRational)Source

def >>(other : Int)Source

Divides the rational by (2 ** other)

require "big"

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

def absSource

Description copied from struct Number

Returns the absolute value of this number.

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

def ceilSource

def cloneSource

def denominatorSource

def floorSource

def hash(hasher)Source

TODO improve this

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 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 invSource

Returns a new BigRational as 1/r.

This will raise an exception if rational is 0.

def numeratorSource

def to_big_dSource

Converts self to BigDecimal.

def to_big_fSource

def to_big_iSource

def to_fSource

Returns the Float64 representing this rational.

def to_f!Source

def to_f32Source

def to_f32!Source

def to_f64Source

def to_f64!Source

def to_i16(*args, **options)Source

def to_i16(*args, **options, &block)Source

def to_i32(*args, **options)Source

def to_i32(*args, **options, &block)Source

def to_i64(*args, **options)Source

def to_i64(*args, **options, &block)Source

def to_i8(*args, **options, &block)Source

def to_i8(*args, **options)Source

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_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_u16(*args, **options)Source

def to_u16(*args, **options, &block)Source

def to_u32(*args, **options)Source

def to_u32(*args, **options, &block)Source

def to_u64(*args, **options, &block)Source

def to_u64(*args, **options)Source

def to_u8(*args, **options, &block)Source

def to_u8(*args, **options)Source

def to_unsafeSource

def truncSource

© 2012–2019 Manas Technology Solutions.
Licensed under the Apache License, Version 2.0.
https://crystal-lang.org/api/0.31.1/BigRational.html