# class Int

class Int is Cool does Real { ... }

`Int`

objects store integral numbers of arbitrary size. `Int`

s are immutable.

There are two main syntax forms for `Int`

literals

123 # Int in decimal notation :16<BEEF> # Int in radix notations

Both forms allow underscores between any two digits which can serve as visual separators, but don't carry any meaning:

5_00000 # five Lakhs 500_000 # five hundred thousand

# Methods

## routine chr

multi sub chr(Int:D ) returns Str:D multi method chr(Int:D:) returns Str:D

Returns a one-character string, by interpreting the integer as a Unicode codepoint number and converting it the corresponding character.

## routine expmod

multi sub expmod (Int:D: Int $y, Int $mod) returns Int:D multi method expmod (Int:D: Int $y, Int $mod) returns Int:D

Returns the given `Int`

raised to the `$y`

power within modulus `$mod`

.

## routine is-prime

multi sub is-prime (Int:D: Int $tries = 100) returns Bool:D multi method is-prime (Int:D: Int $tries = 100) returns Bool:D

Returns `True`

if this `Int`

is known to be a prime, or is likely to be a prime based on a probabilistic Miller-Rabin test. `$tries`

is the maximal number of iterations the test is allowed to do.

Returns `False`

if this `Int`

is known not to be a prime.

# Operators

## infix div

multi sub infix:<div>(Int:D, Int:D) returns Int:D

Does an integer division, rounded down.

# Type graph

Below you should see an imgage showing the type relations for Int. If not, try the PNG version.

# Methods supplied by role Real

Int 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 class Any

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

# Methods supplied by class Mu

Int 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`

.