# class FatRat

Rational number (arbitrary-precision)

class FatRat is Cool does Rational[Int, Int]

A `FatRat`

is a rational number stored with arbitrary size numerator and denominator. Arithmetic operations involving a `FatRat`

and optionally Int or Rat objects return a `FatRat`

, avoiding loss of precision.

Since, unlike Rat, FatRat arithmetics do not fall back Num at some point, there is a risk that repeated arithmetic operations generate pathologically large numerators and denominators.

There are two common ways to generate `FatRat`

objects: through the `FatRat.new(Int, Int)`

constructor, which generates them from numerator and denominator, or by calling the `.FatRat`

method on an Int or Rat object.

# Type graph

Below you should see a clickable image showing the type relations for FatRat that links to the documentation pages for the related types. If not, try the PNG version instead.

# Methods supplied by role Rational

FatRat does role Rational, which provides the following methods:

## method new

method new(NuT:D $numerator, DenomT:D $denominator) returns Rational:D

Creates a new rational object from numerator and denominator.

## method numerator

method numerator(Rational:D:) returns NuT:D

Returns the numerator.

## method denominator

method denominator(Rational:D:) returns DenomT:D

Returns the denominator.

## method nude

method nude(Rational:D:) returns Positional

Returns a list of the numerator and denominator.

## method norm

method norm(Rational:D:) returns Rational:D

Returns a normalized Rational object, i.e. with positive denominator, and numerator and denominator coprime.

# Methods supplied by role Real

FatRat does role Real, which provides the following methods:

## method Rat

method Rat(Real:D: Real $epsilon = 1e-6)

Converts the number to a `Rat`

with the precision `$epsilon`

.

## method sign

method sign(Real:D:)

Returns `-1`

if the number is negative, `0`

if it is zero and `1`

otherwise.

## method round

method round(Real:D: $scale = 1)

Rounds the number to scale `$scale`

. If `$scale`

is 1, rounds to an integer. If scale is `0.1`

, rounds to one digit after the comma etc.

## method floor

method floor(Real:D) returns Int:D

Return the largest integer not greater than the number.

## method ceiling

method ceiling(Real:D) returns Int:D

Returns the smallest integer not less than the number.

## method truncate

method truncate(Real:D) returns Int:D

Rounds the number towards zero.

## method base

method base(Real:D: Int:D $base where 2..36) returns Str:D

Converts the number to a string, using `$base`

as base. For `$base`

larger than ten, capital Latin letters are used.

255.base(16) # 'FF'

# Methods supplied by role Numeric

FatRat does role Numeric, which provides the following methods:

## method Real

method Real(Numeric:D:) returns Real:D

If this `Numeric`

is equivalent to a `Real`

, return that `Real`

. Fail with `X::Numeric::Real`

otherwise.

## method Int

method Int(Numeric:D:) returns Int:D

If this `Numeric`

is equivalent to a `Real`

, return the equivalent of calling `truncate`

on that `Real`

to get an `Int`

. Fail with `X::Numeric::Real`

otherwise.

## method Rat

method Rat(Numeric:D: Real $epsilon = 1.0e-6) returns Rat:D

If this `Numeric`

is equivalent to a `Real`

, return a `Rat`

which is within `$epsilon`

of that `Real`

's value. Fail with `X::Numeric::Real`

otherwise.

## method Num

method Num(Numeric:D:) returns Num:D

If this `Numeric`

is equivalent to a `Real`

, return that `Real`

as a `Num`

as accurately as is possible. Fail with `X::Numeric::Real`

otherwise.

## method ACCEPTS

multi method ACCEPTS(Numeric:D: $other)

Returns True if `$other`

is numerically the same as the invocant.

## method roots

multi method roots(Numeric:D: Int:D $n) returns Positional

Returns a list of the `$n`

complex roots, which evaluate to the original number when raised to the `$n`

th power.

## method conj

multi method conj(Numeric:D) returns Numeric:D

Returns the complex conjugate of the number. Returns the number itself for real numbers.

## method Bool

multi method Bool(Numeric:D:)

Returns `False`

if the number is equivalent to zero, and `True`

otherwise.

## method succ

method succ(Numerid:D:)

Returns the number incremented by one (successor).

## method pred

method pred(Numerid:D:)

Returns the number decremented by one (predecessor).

# Methods supplied by class Any

FatRat inherits from class Any, which provides the following methods:

## method ACCEPTS

multi method ACCEPTS(Any:D: Mu $other)

Returns `True`

if `$other === self`

(i.e. it checks object identity).

## method any

Interprets the invocant as a list and creates an `any`

-Junction from it.

## method all

Interprets the invocant as a list and creates an `all`

-Junction from it.

## method one

Interprets the invocant as a list and creates an `one`

-Junction from it.

## method none

Interprets the invocant as a list and creates an `none`

-Junction from it.

## method list

Interprets the invocant as a list, and returns that list.

## method flat

Interprets the invocant as a list, flattens it, and returns that list.

## method eager

Interprets the invocant as a list, evaluates it eagerly, and returns that list.

## method elems

Interprets the invocant as a list, and returns the number of elements in the list.

## method end

Interprets the invocant as a list, and returns the last index of that list.

# Methods supplied by class Mu

FatRat inherits from class Mu, which provides the following methods:

## method Str

multi method Str() returns Str

Returns a string representation of the invocant, intended to be machine readable.

## method clone

method clone(*%twiddles)

Creates a shallow clone of the invocant. If named arguments are passed to it, their values are used in every place where an attribute name matches the name of a named argument.

## method new

multi method new(*%attrinit)

Default method for constructing (create + initialize) new objects of a class. This method expects only named arguments which are then used to initialize attributes with accessors of the same name.

Classes may provide their own `new`

method to override this default.

## method bless

method bless(*%attrinit) returns Mu:D

Lower-level object construction method than `new`

.

Creates a new object of the same type as the invocant, uses the named arguments to initialize attributes, and returns the created object.

You can use this method when writing custom constructors:

class Point { has $.x; has $.y; multi method new($x, $y) { self.bless(:$x, :$y); } } my $p = Point.new(-1, 1);

(Though each time you write a custom constructor, remember that it makes subclassing harder).

## method CREATE

method CREATE() returns Mu:D

Allocates a new object of the same type as the invocant, without initializing any attributes.

## method print

multi method print() returns Bool:D

Prints value to `$*OUT`

after stringification using `.Str`

method without newline at end.

## method say

multi method say() returns Bool:D

Prints value to `$*OUT`

after stringification using `.gist`

method with newline at end.

## method ACCEPTS

multi method ACCEPTS(Mu:U: $other)

Performs a type check. Returns `True`

if `$other`

conforms to the invocant (which is always a type object or failure).

This is the method that is triggered on smart-matching against type objects, for example in `if $var ~~ Int { ... }`

.

## method WHICH

multi method WHICH() returns ObjAt:D

Returns an object of type ObjAt which uniquely identifies the object. Value types override this method which makes sure that two equivalent objects return the same return value from `WHICH`

.