This module implements rational numbers, consisting of a numerator num and a denominator den, both of type int. The denominator can not be 0.
Rational[T] = object num*, den*: T
proc initRational[T: SomeInteger](num, den: T): Rational[T]
proc `//`[T](num, den: T): Rational[T]
var x = 1//3 + 1//5
proc `$`[T](x: Rational[T]): string
proc toRational[T: SomeInteger](x: T): Rational[T]
proc toRational(x: float; n: int = high(int) shr 32): Rational[int] {...}{.raises: [], tags: [].}
Calculates the best rational numerator and denominator that approximates to x, where the denominator is smaller than n (default is the largest possible int to give maximum resolution).
The algorithm is based on the theory of continued fractions.
import math, rationals for i in 1..10: let t = (10 ^ (i+3)).int let x = toRational(PI, t) let newPI = x.num / x.den echo x, " ", newPI, " error: ", PI - newPI, " ", t
proc toFloat[T](x: Rational[T]): float
proc toInt[T](x: Rational[T]): int
proc reduce[T: SomeInteger](x: var Rational[T])
proc `+`[T](x, y: Rational[T]): Rational[T]
proc `+`[T](x: Rational[T]; y: T): Rational[T]
proc `+`[T](x: T; y: Rational[T]): Rational[T]
proc `+=`[T](x: var Rational[T]; y: Rational[T])
proc `+=`[T](x: var Rational[T]; y: T)
proc `-`[T](x: Rational[T]): Rational[T]
proc `-`[T](x, y: Rational[T]): Rational[T]
proc `-`[T](x: Rational[T]; y: T): Rational[T]
proc `-`[T](x: T; y: Rational[T]): Rational[T]
proc `-=`[T](x: var Rational[T]; y: Rational[T])
proc `-=`[T](x: var Rational[T]; y: T)
proc `*`[T](x, y: Rational[T]): Rational[T]
proc `*`[T](x: Rational[T]; y: T): Rational[T]
proc `*`[T](x: T; y: Rational[T]): Rational[T]
proc `*=`[T](x: var Rational[T]; y: Rational[T])
proc `*=`[T](x: var Rational[T]; y: T)
proc reciprocal[T](x: Rational[T]): Rational[T]
proc `/`[T](x, y: Rational[T]): Rational[T]
proc `/`[T](x: Rational[T]; y: T): Rational[T]
proc `/`[T](x: T; y: Rational[T]): Rational[T]
proc `/=`[T](x: var Rational[T]; y: Rational[T])
proc `/=`[T](x: var Rational[T]; y: T)
proc cmp(x, y: Rational): int {...}{.procvar.}
proc `<`(x, y: Rational): bool
proc `<=`(x, y: Rational): bool
proc `==`(x, y: Rational): bool
proc abs[T](x: Rational[T]): Rational[T]
proc `div`[T: SomeInteger](x, y: Rational[T]): T
proc `mod`[T: SomeInteger](x, y: Rational[T]): Rational[T]
x - (x div y) * y
. proc floorDiv[T: SomeInteger](x, y: Rational[T]): T
Computes the rational floor division.
Floor division is conceptually defined as floor(x / y)
. This is different from the div
operator, which is defined as trunc(x / y)
. That is, div
rounds towards 0
and floorDiv
rounds down.
proc floorMod[T: SomeInteger](x, y: Rational[T]): Rational[T]
Computes the rational modulo by floor division (modulo).
This is same as x - floorDiv(x, y) * y
. This proc behaves the same as the %
operator in python.
proc hash[T](x: Rational[T]): Hash
© 2006–2018 Andreas Rumpf
Licensed under the MIT License.
https://nim-lang.org/docs/rationals.html