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

Returns self.

def +(other : BigFloat) #

def +(other : Complex) #

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(range : Range) #

Clamps a value within range.

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

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 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) # => {-3, 2}

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

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

def to_c #

def to_yaml(yaml : YAML::Generator) #

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)