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 # Float64The underscore _ before the suffix is optional.
Underscores can be used to make some numbers more readable:
1_000_000.111_111 # better than 1000000.111111See Float literals in the language reference.
Included Modules
Direct Known Subclasses
Defined in:
big/big_decimal.crbig/big_float.cr
big/big_int.cr
big/big_rational.cr
big/number.cr
float.cr
float/fast_float.cr
json/to_json.cr
time/span.cr
yaml/to_yaml.cr
Constructors
- 
        .from_io(io : IO, format : IO::ByteFormat) : self
        
          Reads a float from the given io in the given format. 
Instance Method Summary
- #%(other)
- 
        #-
        
          Negates this value's sign. 
- 
        #//(other)
        
          Divides selfby other using floored division.
- #<=>(other : BigInt)
- #<=>(other : BigFloat)
- #<=>(other : BigRational)
- 
        #<=>(other : BigDecimal)
        
          The comparison operator. 
- 
        #days : Time::Span
        
          Returns a Time::Spanofselfdays.
- #fdiv(other : BigInt | BigFloat | BigDecimal | BigRational) : self
- 
        #finite? : Bool
        
          Returns whether this value is finite, i.e. 
- 
        #hours : Time::Span
        
          Returns a Time::Spanofselfhours.
- 
        #infinite? : Int32 | Nil
        
          Checks whether this value is infinite. 
- 
        #microseconds : Time::Span
        
          Returns a Time::Spanofselfmicroseconds.
- 
        #milliseconds : Time::Span
        
          Returns a Time::Spanofselfmilliseconds.
- 
        #minutes : Time::Span
        
          Returns a Time::Spanofselfminutes.
- #modulo(other)
- 
        #nan? : Bool
        
          Returns whether this value is a not-a-number. 
- 
        #nanoseconds : Time::Span
        
          Returns a Time::Spanofselfnanoseconds.
- #remainder(other)
- 
        #seconds : Time::Span
        
          Returns a Time::Spanofselfseconds.
- 
        #to_big_d : BigDecimal
        
          Converts selftoBigDecimal.
- 
        #to_big_i : BigInt
        
          Returns a BigIntrepresenting this float (rounded usingfloor).
- 
        #to_big_r : BigRational
        
          Returns a BigRationalrepresenting this float.
- 
        #to_io(io : IO, format : IO::ByteFormat) : Nil
        
          Writes this float to the given io in the given format. 
- #to_json(json : JSON::Builder) : Nil
- #to_json_object_key : String
- #to_yaml(yaml : YAML::Nodes::Builder) : Nil
- 
        #weeks : Time::Span
        
          Returns a Time::Spanofselfweeks.
Instance methods inherited from module Comparable(BigDecimal)
  
  
    
      <(other : T) : Bool
    <, 
    
  
    
      <=(other : T)
    <=, 
    
  
    
      <=>(other : T)
    <=>, 
    
  
    
      ==(other : T)
    ==, 
    
  
    
      >(other : T) : Bool
    >, 
    
  
    
      >=(other : T)
    >=, 
    
  
    
      clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from module Comparable(BigRational)
  
  
    
      <(other : T) : Bool
    <, 
    
  
    
      <=(other : T)
    <=, 
    
  
    
      <=>(other : T)
    <=>, 
    
  
    
      ==(other : T)
    ==, 
    
  
    
      >(other : T) : Bool
    >, 
    
  
    
      >=(other : T)
    >=, 
    
  
    
      clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from module Comparable(BigInt)
  
  
    
      <(other : T) : Bool
    <, 
    
  
    
      <=(other : T)
    <=, 
    
  
    
      <=>(other : T)
    <=>, 
    
  
    
      ==(other : T)
    ==, 
    
  
    
      >(other : T) : Bool
    >, 
    
  
    
      >=(other : T)
    >=, 
    
  
    
      clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from struct Number
  
  
    
      *(other : BigFloat) : BigFloat*(other : Complex) : Complex *, +(other : BigFloat)
+(other : Complex) : Complex
+ +, -(other : BigFloat)
-(other : Complex) : Complex -, /(other : BigFloat) : BigFloat
/(other : Complex) : Complex /, //(other) //, <=>(other) : Int32 | Nil <=>, ==(other : Complex) ==, abs : self abs, abs2 abs2, cis : Complex cis, divmod(number) divmod, format(io : IO, separator = '.', delimiter = ',', decimal_places : Int | Nil = nil, *, group : Int = 3, only_significant : Bool = false) : Nil
format(separator = '.', delimiter = ',', decimal_places : Int | Nil = nil, *, group : Int = 3, only_significant : Bool = false) : String format, hash(hasher) hash, humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, prefixes : Indexable = SI_PREFIXES) : Nil
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, prefixes : Proc) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, prefixes = SI_PREFIXES) : String
humanize(io : IO, precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, &prefixes : Int32, Float64 -> Tuple(Int32, _) | Tuple(Int32, _, Bool)) : Nil
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, &) : String
humanize(precision = 3, separator = '.', delimiter = ',', *, base = 10 ** 3, significant = true, unit_separator = nil, prefixes : Proc) : String humanize, i : Complex i, integer? : Bool integer?, negative? : Bool negative?, positive? : Bool positive?, round(mode : RoundingMode = :ties_even) : self
round(digits : Number, base = 10, *, mode : RoundingMode = :ties_even) round, sign : Int32 sign, significant(digits, base = 10) significant, step(*, to limit = nil, exclusive : Bool = false, &) : Nil
step(*, to limit = nil, exclusive : Bool = false) step, to_big_f : BigFloat to_big_f, to_c : Complex to_c, to_yaml(yaml : YAML::Nodes::Builder) : Nil to_yaml, zero? : Bool zero?
Constructor methods inherited from struct Number
  
  
    
      additive_identity : self
    additive_identity, 
    
  
    
      multiplicative_identity : self
    multiplicative_identity, 
    
  
    
      zero : self
    zero
    
  
      
  Class methods inherited from struct Number
  
  
    
      si_prefix(magnitude : Int, prefixes = SI_PREFIXES) : Char | Nil
    si_prefix
    
  
      
  Macros inherited from struct Number
  
  
    
      [](*nums)
    [], 
    
  
    
      slice(*nums, read_only = false)
    slice, 
    
  
    
      static_array(*nums)
    static_array
    
  
    
      
  Instance methods inherited from module Comparable(BigFloat)
  
  
    
      <(other : T) : Bool
    <, 
    
  
    
      <=(other : T)
    <=, 
    
  
    
      <=>(other : T)
    <=>, 
    
  
    
      ==(other : T)
    ==, 
    
  
    
      >(other : T) : Bool
    >, 
    
  
    
      >=(other : T)
    >=, 
    
  
    
      clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from module Steppable
  
  
    
      step(*, to limit = nil, by step, exclusive : Bool = false, &) : Nilstep(*, to limit = nil, by step, exclusive : Bool = false) step
Instance methods inherited from module Comparable(Number)
  
  
    
      <(other : T) : Bool
    <, 
    
  
    
      <=(other : T)
    <=, 
    
  
    
      <=>(other : T)
    <=>, 
    
  
    
      ==(other : T)
    ==, 
    
  
    
      >(other : T) : Bool
    >, 
    
  
    
      >=(other : T)
    >=, 
    
  
    
      clamp(min, max)clamp(range : Range) clamp
Instance methods inherited from struct Value
  
  
    
      ==(other : JSON::Any)==(other : YAML::Any)
==(other) ==, dup dup
Instance methods inherited from class Object
  
  
    
      ! : Bool
    !, 
    
  
    
      !=(other)
    !=, 
    
  
    
      !~(other)
    !~, 
    
  
    
      ==(other)
    ==, 
    
  
    
      ===(other : JSON::Any)===(other : YAML::Any)
===(other) ===, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String to_yaml, try(&) try, unsafe_as(type : T.class) forall T unsafe_as
Class methods inherited from class Object
  
  
    
      from_json(string_or_io, root : String)from_json(string_or_io) from_json, from_yaml(string_or_io : String | IO) from_yaml
Macros inherited from class Object
  
  
    
      class_getter(*names, &block)
    class_getter, 
    
  
    
      class_getter!(*names)
    class_getter!, 
    
  
    
      class_getter?(*names, &block)
    class_getter?, 
    
  
    
      class_property(*names, &block)
    class_property, 
    
  
    
      class_property!(*names)
    class_property!, 
    
  
    
      class_property?(*names, &block)
    class_property?, 
    
  
    
      class_setter(*names)
    class_setter, 
    
  
    
      def_clone
    def_clone, 
    
  
    
      def_equals(*fields)
    def_equals, 
    
  
    
      def_equals_and_hash(*fields)
    def_equals_and_hash, 
    
  
    
      def_hash(*fields)
    def_hash, 
    
  
    
      delegate(*methods, to object)
    delegate, 
    
  
    
      forward_missing_to(delegate)
    forward_missing_to, 
    
  
    
      getter(*names, &block)
    getter, 
    
  
    
      getter!(*names)
    getter!, 
    
  
    
      getter?(*names, &block)
    getter?, 
    
  
    
      property(*names, &block)
    property, 
    
  
    
      property!(*names)
    property!, 
    
  
    
      property?(*names, &block)
    property?, 
    
  
    
      setter(*names)
    setter
    
  
    
  Constructor Detail
Instance Method Detail
Divides self by other using floored division.
The result will be of the same type as self.
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]Returns whether this value is finite, i.e. it is neither infinite nor a not-a-number.
Checks whether this value is infinite. Returns 1 if this value is positive
infinity, -1 if this value is negative infinity, or nil otherwise.
Returns whether this value is a not-a-number.
This includes both quiet and signalling NaNs from IEEE 754.
Converts self to BigDecimal.
NOTE Floats are fundamentally less precise than BigDecimals, which makes conversion to them risky.
require "big"
1212341515125412412412421.0.to_big_dReturns a BigInt representing this float (rounded using floor).
require "big"
1212341515125412412412421.0.to_big_iReturns a BigRational representing this float.
require "big"
123.0.to_big_r