# class Int

Integer (arbitrary-precision)

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.

## routine lsb

multi method lsb(Int:D:) multi sub lsb(Int:D)

Returns Nil if the number is 0. Otherwise returns the zero-based index from the right of the first 1 in the binary representation of the number.

say 0b01011.lsb; # 0 say 0b01010.lsb; # 1 say 0b10100.lsb; # 2 say 0b01000.lsb; # 3 say 0b10000.lsb; # 4

## routine msb

multi method msb(Int:D:) multi sub msb(Int:D)

Returns Nil if the number is 0. Otherwise returns the zero-based index from the left of the first 1 in the binary representation of the number.

say 0b00001.msb; # 0 say 0b00011.msb; # 1 say 0b00101.msb; # 2 say 0b01010.msb; # 3 say 0b10011.msb; # 4

# 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 a clickable image showing the type relations for Int that links to the documentation pages for the related types. If not, try the PNG version instead.

# 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 role Numeric

Int 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

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.

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

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`

.