# abstract struct Number

## Overview

The top-level number type.

number.cr
big/big_float.cr
yaml/to_yaml.cr
complex.cr

## Macro Summary

• [](*nums)

Creates an `Array` of self with the given values, which will be casted to this type with the `new` method (defined in each Number type).

• slice(*nums)

Creates a `Slice` of self with the given values, which will be casted to this type with the `new` method (defined in each Number type).

• static_array(*nums)

Creates a `StaticArray` of self with the given values, which will be casted to this type with the `new` method (defined in each Number type).

, , , , ,

, , , , ,

,

### Instance methods inherited from class `Object`

, , , , , , , , , , , , , , , , ,

### Class methods inherited from class `Object`

, , , , , , , , , , , ,

## Class Method Detail

def self.zero : self #

## Instance Method Detail

def *(other : Complex) #

def *(other : BigFloat) #

def +(other : BigFloat) #

def +(other : Complex) #

def + #

Returns self.

def -(other : Complex) #

def -(other : BigFloat) #

def /(other : Complex) #

def <=>(other : BigFloat) #

def <=>(other) #

Implements the comparison operator.

See `Object#<=>`

def ==(other : Complex) #

def abs #

Returns the absolute value of this number.

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

def abs2 #

Returns the square of self (`self * self`).

``````4.abs2   # => 16
1.5.abs2 # => 2.25``````

def cis #

def clamp(min, max) #

Clamps a value between min and max.

``````5.clamp(10, 100)   # => 10
50.clamp(10, 100)  # => 50
500.clamp(10, 100) # => 100``````

def clamp(range : Range) #

Clamps a value within `range`.

``````5.clamp(10..100)   # => 10
50.clamp(10..100)  # => 50
500.clamp(10..100) # => 100``````

def divmod(number) #

Returns a `Tuple` of two elements containing the quotient and modulus obtained by dividing self by number.

``````11.divmod(3)  # => {3, 2}
11.divmod(-3) # => {-4, -1}``````

def i #

def round(digits, base = 10) #

Rounds this number to a given precision in decimal digits.

``-1763.116.round(2) # => -1763.12``

def sign #

Returns the sign of this number as an Int32.

• -1 if this number is negative
• 0 if this number is zero
• 1 if this number is positive
``````123.sign # => 1
0.sign   # => 0
-42.sign # => -1``````

def significant(digits, base = 10) #

Keeps digits significants digits of this number in the given base.

``````1234.567.significant(1) # => 1000
1234.567.significant(2) # => 1200
1234.567.significant(3) # => 1230
1234.567.significant(4) # => 1235
1234.567.significant(5) # => 1234.6
1234.567.significant(6) # => 1234.57
1234.567.significant(7) # => 1234.567
1234.567.significant(8) # => 1234.567

15.159.significant(1, base = 2) # => 16``````

def step(limit = nil, by = 1, &block) #

Invokes the given block with the sequence of numbers starting at `self`, incremented by `by` on each call, and with an optional `limit`.

``````3.step(by: 2, limit: 10) do |n|
puts n
end``````

Output:

``````3
5
7
9``````

def step(limit = nil, by = 1) #

def to_big_f #

def to_c #

def to_yaml(emitter : YAML::Emitter) #

## Macro Detail

macro [](*nums) #

Creates an `Array` of self with the given values, which will be casted to this type with the `new` method (defined in each Number type).

``````floats = Float64[1, 2, 3, 4]
floats.class # => Array(Float64)

ints = Int64[1, 2, 3]
ints.class # => Array(Int64)``````

macro slice(*nums) #

Creates a `Slice` of self with the given values, which will be casted to this type with the `new` method (defined in each Number type).

The slice is allocated on the heap.

``````floats = Float64.slice(1, 2, 3, 4)
floats.class # => Slice(Float64)

ints = Int64.slice(1, 2, 3)
ints.class # => Slice(Int64)``````

macro static_array(*nums) #

Creates a `StaticArray` of self with the given values, which will be casted to this type with the `new` method (defined in each Number type).

``````floats = Float64.static_array(1, 2, 3, 4)
floats.class # => StaticArray(Float64, 4)

ints = Int64.static_array(1, 2, 3)
ints.class # => StaticArray(Int64, 3)``````