W3cubDocs

/Crystal 0.31

abstract struct Float

Overview

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

Included Modules

Direct Known Subclasses

Defined in:

float.cr
time/span.cr
big/big_int.cr
big/big_rational.cr
big/big_decimal.cr
json/to_json.cr

Constructors

Instance Method Summary

Instance methods inherited from module Comparable(BigDecimal)

<, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

Instance methods inherited from module Comparable(BigRational)

<, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

Instance methods inherited from module Comparable(BigInt)

<, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

Instance methods inherited from struct Number

*(other : Complex)
*(other : BigFloat) *
, +(other : BigFloat)
+(other : Complex)
+ +
, -(other : Complex)
-(other : BigFloat) -
, /(other : Complex)
/(other : BigFloat) /
, //(other) //, <=>(other : BigFloat)
<=>(other) : Int32? <=>
, ==(other : Complex) ==, abs abs, abs2 abs2, cis cis, clamp(range : Range)
clamp(min, max) clamp
, divmod(number) divmod, format(separator = '.', delimiter = ',', decimal_places : Int? = nil, *, group : Int = 3, only_significant : Bool = false) : String
format(io : IO, separator = '.', delimiter = ',', decimal_places : Int? = nil, *, group : Int = 3, only_significant : Bool = false) : Nil format
, humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Indexable = SI_PREFIXES) : Nil
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Proc) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes = SI_PREFIXES) : String
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &prefixes : Int32, Float64 -> Tuple(Int32, UNDERSCORE) | Tuple(Int32, UNDERSCORE, Bool)) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, &block) : String
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, prefixes : Proc) : Nil humanize
, i i, round(digits = 0, base = 10) round, sign sign, significant(digits, base = 10) significant, step(*, to = nil, by = 1)
step(*, to = nil, by = 1, &block) step
, to_big_f to_big_f, to_c to_c, to_yaml(yaml : YAML::Nodes::Builder) to_yaml, zero? : Bool zero?

Constructor methods inherited from struct Number

zero : self zero

Class methods inherited from struct Number

si_prefix(magnitude : Int, prefixes = SI_PREFIXES) : Char? si_prefix

Instance methods inherited from module Comparable(BigFloat)

<, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

Instance methods inherited from module Comparable(Number)

<, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=

Instance methods inherited from struct Value

==(other : JSON::Any)
==(other : YAML::Any)
==(other) ==
, dup dup

Instance methods inherited from class Object

!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other) ===
, =~(other) =~, class class, dup dup, hash(hasher)
hash hash
, inspect(io : IO) : Nil
inspect : String inspect
, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json(io : IO)
to_json to_json
, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json
, to_s : String
to_s(io : IO) : Nil to_s
, to_yaml(io : IO)
to_yaml to_yaml
, try(&block) try, unsafe_as(type : T.class) forall T unsafe_as

Constructor methods inherited from class Object

from_json(string_or_io, root : String) : self
from_json(string_or_io) : self from_json
, from_yaml(string_or_io : String | IO) : self from_yaml

Constructor Detail

def self.from_io(io : IO, format : IO::ByteFormat) : selfSource

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

Instance Method Detail

def %(other)Source

def -Source

def //(other)Source

Description copied from struct Number

Divides self by other using floored division.

The result will be of the same type as self.

def <=>(other : BigDecimal)Source

Description copied from module Comparable(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 greter 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]

def <=>(other : BigRational)Source

def <=>(other : BigInt)Source

def days : Time::SpanSource

Returns a Time::Span of self days.

def fdiv(other) : selfSource

Float divivision that will obey the left hand side argument type.

def finite?Source

def hash(hasher)Source

def hours : Time::SpanSource

Returns a Time::Span of self hours.

def infinite?Source

def microseconds : Time::SpanSource

Returns a Time::Span of self microseconds.

def milliseconds : Time::SpanSource

Returns a Time::Span of self milliseconds.

def minutes : Time::SpanSource

Returns a Time::Span of self minutes.

def modulo(other)Source

def nan?Source

def nanoseconds : Time::SpanSource

Returns a Time::Span of self nanoseconds.

def remainder(other)Source

def seconds : Time::SpanSource

Returns a Time::Span of self seconds.

def to_big_dSource

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

def to_big_i : BigIntSource

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

require "big"

1212341515125412412412421.0.to_big_i

def to_big_rSource

Returns a BigRational representing this float.

require "big"

123.0.to_big_r

def to_io(io : IO, format : IO::ByteFormat)Source

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

def to_json(json : JSON::Builder)Source

def to_json_object_keySource

def weeks : Time::SpanSource

Returns a Time::Span of self weeks.

© 2012–2019 Manas Technology Solutions.
Licensed under the Apache License, Version 2.0.
https://crystal-lang.org/api/0.31.1/Float.html