struct

Float

Inherits Comparable / Comparable / Comparable / Number / Comparable / Steppable / Comparable / Value / Object

Float is the base type of all floating point numbers.

There are two floating point types, Float32 and Float64, which correspond to the binary32 and binary64 types defined by IEEE.

A floating point literal is an optional + or - sign, followed by a sequence of numbers or underscores, followed by a dot, followed by numbers or underscores, followed by an optional exponent suffix, followed by an optional type suffix. If no suffix is present, the literal's type is Float64.

1.0     # Float64
1.0_f32 # Float32
1_f32   # Float32

1e10   # Float64
1.5e10 # Float64
1.5e-7 # Float64

+1.3 # Float64
-0.5 # Float64

The underscore _ before the suffix is optional.

Underscores can be used to make some numbers more readable:

1_000_000.111_111 # better than 1000000.111111

See Float literals in the language reference.

Constructors

from_io(io : IO, format : IO::ByteFormat) : self

Reads a float from the given io in the given format. See also: IO#read_bytes.

Instance methods

%(other)

-

Negates this value's sign.

//(other)

Divides self by other using floored division.

The result will be of the same type as self.

<=>(other : BigInt)

<=>(other : BigFloat)

<=>(other : BigRational)

<=>(other : BigDecimal)

The comparison operator. Returns 0 if the two objects are equal, a negative number if this object is considered less than other, a positive number if this object is considered greater than other, or nil if the two objects are not comparable.

Subclasses define this method to provide class-specific ordering.

The comparison operator is usually used to sort values:

# Sort in a descending way:
[3, 1, 2].sort { |x, y| y <=> x } # => [3, 2, 1]

# Sort in an ascending way:
[3, 1, 2].sort { |x, y| x <=> y } # => [1, 2, 3]

days

Returns a Time::Span of self days.

fdiv(other : BigInt | BigFloat | BigDecimal | BigRational) : self

finite?

Returns whether this value is finite, i.e. it is neither infinite nor a not-a-number.

hours

Returns a Time::Span of self hours.

infinite?

Checks whether this value is infinite. Returns 1 if this value is positive infinity, -1 if this value is negative infinity, or nil otherwise.

microseconds

Returns a Time::Span of self microseconds.

milliseconds

Returns a Time::Span of self milliseconds.

minutes

Returns a Time::Span of self minutes.

modulo(other)

nan?

Returns whether this value is a not-a-number.

This includes both quiet and signalling NaNs from IEEE 754.

nanoseconds

Returns a Time::Span of self nanoseconds.

remainder(other)

seconds

Returns a Time::Span of self seconds.

to_big_d

Converts self to BigDecimal.

NOTE: Floats are fundamentally less precise than BigDecimals, which makes conversion to them risky.

require "big"
1212341515125412412412421.0.to_big_d

to_big_i

Returns a BigInt representing this float (rounded using floor).

require "big"

1212341515125412412412421.0.to_big_i

to_big_r

Returns a BigRational representing this float.

require "big"

123.0.to_big_r

to_io(io : IO, format : IO::ByteFormat) : Nil

Writes this float to the given io in the given format. See also: IO#write_bytes.

to_json(json : JSON::Builder) : Nil

to_json_object_key

to_yaml(yaml : YAML::Nodes::Builder) : Nil

weeks

Returns a Time::Span of self weeks.

Nested types

Float::Primitive