class Numeric

Constants

EXABYTE
GIGABYTE
KILOBYTE
MEGABYTE
PETABYTE
TERABYTE

Public Instance Methods

ago(time = ::Time.current) click to toggle source

Reads best without arguments: 10.minutes.ago

# File lib/active_support/core_ext/numeric/time.rb, line 65
def ago(time = ::Time.current)
  time - self
end
Also aliased as: until
byte()
Alias for: bytes
bytes() click to toggle source

Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes

# File lib/active_support/core_ext/numeric/bytes.rb, line 10
def bytes
  self
end
Also aliased as: byte
day()
Alias for: days
days() click to toggle source
# File lib/active_support/core_ext/numeric/time.rb, line 49
def days
  ActiveSupport::Duration.new(self * 24.hours, [[:days, self]])
end
Also aliased as: day
duplicable?() click to toggle source

Numbers are not duplicable:

3.duplicable? # => false
3.dup         # => TypeError: can't dup Fixnum
# File lib/active_support/core_ext/object/duplicable.rb, line 74
def duplicable?
  false
end
exabyte()
Alias for: exabytes
exabytes() click to toggle source
# File lib/active_support/core_ext/numeric/bytes.rb, line 40
def exabytes
  self * EXABYTE
end
Also aliased as: exabyte
fortnight()
Alias for: fortnights
fortnights() click to toggle source
# File lib/active_support/core_ext/numeric/time.rb, line 59
def fortnights
  ActiveSupport::Duration.new(self * 2.weeks, [[:days, self * 14]])
end
Also aliased as: fortnight
from_now(time = ::Time.current)

Reads best without arguments: 10.minutes.from_now

Alias for: since
gigabyte()
Alias for: gigabytes
gigabytes() click to toggle source
# File lib/active_support/core_ext/numeric/bytes.rb, line 25
def gigabytes
  self * GIGABYTE
end
Also aliased as: gigabyte
hour()
Alias for: hours
hours() click to toggle source
# File lib/active_support/core_ext/numeric/time.rb, line 44
def hours
  ActiveSupport::Duration.new(self * 3600, [[:seconds, self * 3600]])
end
Also aliased as: hour
html_safe?() click to toggle source
# File lib/active_support/core_ext/string/output_safety.rb, line 78
def html_safe?
  true
end
kilobyte()
Alias for: kilobytes
kilobytes() click to toggle source
# File lib/active_support/core_ext/numeric/bytes.rb, line 15
def kilobytes
  self * KILOBYTE
end
Also aliased as: kilobyte
megabyte()
Alias for: megabytes
megabytes() click to toggle source
# File lib/active_support/core_ext/numeric/bytes.rb, line 20
def megabytes
  self * MEGABYTE
end
Also aliased as: megabyte
minute()
Alias for: minutes
minutes() click to toggle source
# File lib/active_support/core_ext/numeric/time.rb, line 39
def minutes
  ActiveSupport::Duration.new(self * 60, [[:seconds, self * 60]])
end
Also aliased as: minute
petabyte()
Alias for: petabytes
petabytes() click to toggle source
# File lib/active_support/core_ext/numeric/bytes.rb, line 35
def petabytes
  self * PETABYTE
end
Also aliased as: petabyte
second()
Alias for: seconds
seconds() click to toggle source

Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.

These methods use Time#advance for precise date calculations when using #from_now, ago, etc. as well as adding or subtracting their results from a Time object. For example:

# equivalent to Time.current.advance(months: 1)
1.month.from_now

# equivalent to Time.current.advance(years: 2)
2.years.from_now

# equivalent to Time.current.advance(months: 4, years: 5)
(4.months + 5.years).from_now

While these methods provide precise calculation when used as in the examples above, care should be taken to note that this is not true if the result of `months', `years', etc is converted before use:

# equivalent to 30.days.to_i.from_now
1.month.to_i.from_now

# equivalent to 365.25.days.to_f.from_now
1.year.to_f.from_now

In such cases, Ruby's core Date and Time should be used for precision date and time arithmetic.

# File lib/active_support/core_ext/numeric/time.rb, line 34
def seconds
  ActiveSupport::Duration.new(self, [[:seconds, self]])
end
Also aliased as: second
since(time = ::Time.current) click to toggle source

Reads best with argument: 10.minutes.since(time)

# File lib/active_support/core_ext/numeric/time.rb, line 73
def since(time = ::Time.current)
  time + self
end
Also aliased as: from_now
terabyte()
Alias for: terabytes
terabytes() click to toggle source
# File lib/active_support/core_ext/numeric/bytes.rb, line 30
def terabytes
  self * TERABYTE
end
Also aliased as: terabyte
to_formatted_s(format = :default, options = {}) click to toggle source

Provides options for converting numbers into formatted strings. Options are provided for phone numbers, currency, percentage, precision, positional notation, file size and pretty printing.

Options

For details on which formats use which options, see ActiveSupport::NumberHelper

Examples

Phone Numbers:
5551234.to_s(:phone)                                     # => 555-1234
1235551234.to_s(:phone)                                  # => 123-555-1234
1235551234.to_s(:phone, area_code: true)                 # => (123) 555-1234
1235551234.to_s(:phone, delimiter: ' ')                  # => 123 555 1234
1235551234.to_s(:phone, area_code: true, extension: 555) # => (123) 555-1234 x 555
1235551234.to_s(:phone, country_code: 1)                 # => +1-123-555-1234
1235551234.to_s(:phone, country_code: 1, extension: 1343, delimiter: '.')
# => +1.123.555.1234 x 1343

Currency:
1234567890.50.to_s(:currency)                 # => $1,234,567,890.50
1234567890.506.to_s(:currency)                # => $1,234,567,890.51
1234567890.506.to_s(:currency, precision: 3)  # => $1,234,567,890.506
1234567890.506.to_s(:currency, locale: :fr)   # => 1 234 567 890,51 €
-1234567890.50.to_s(:currency, negative_format: '(%u%n)')
# => ($1,234,567,890.50)
1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '')
# => £1234567890,50
1234567890.50.to_s(:currency, unit: '£', separator: ',', delimiter: '', format: '%n %u')
# => 1234567890,50 £

Percentage:
100.to_s(:percentage)                                  # => 100.000%
100.to_s(:percentage, precision: 0)                    # => 100%
1000.to_s(:percentage, delimiter: '.', separator: ',') # => 1.000,000%
302.24398923423.to_s(:percentage, precision: 5)        # => 302.24399%
1000.to_s(:percentage, locale: :fr)                    # => 1 000,000%
100.to_s(:percentage, format: '%n  %')                 # => 100  %

Delimited:
12345678.to_s(:delimited)                     # => 12,345,678
12345678.05.to_s(:delimited)                  # => 12,345,678.05
12345678.to_s(:delimited, delimiter: '.')     # => 12.345.678
12345678.to_s(:delimited, delimiter: ',')     # => 12,345,678
12345678.05.to_s(:delimited, separator: ' ')  # => 12,345,678 05
12345678.05.to_s(:delimited, locale: :fr)     # => 12 345 678,05
98765432.98.to_s(:delimited, delimiter: ' ', separator: ',')
# => 98 765 432,98

Rounded:
111.2345.to_s(:rounded)                                      # => 111.235
111.2345.to_s(:rounded, precision: 2)                        # => 111.23
13.to_s(:rounded, precision: 5)                              # => 13.00000
389.32314.to_s(:rounded, precision: 0)                       # => 389
111.2345.to_s(:rounded, significant: true)                   # => 111
111.2345.to_s(:rounded, precision: 1, significant: true)     # => 100
13.to_s(:rounded, precision: 5, significant: true)           # => 13.000
111.234.to_s(:rounded, locale: :fr)                          # => 111,234
13.to_s(:rounded, precision: 5, significant: true, strip_insignificant_zeros: true)
# => 13
389.32314.to_s(:rounded, precision: 4, significant: true)    # => 389.3
1111.2345.to_s(:rounded, precision: 2, separator: ',', delimiter: '.')
# => 1.111,23

Human-friendly size in Bytes:
123.to_s(:human_size)                                   # => 123 Bytes
1234.to_s(:human_size)                                  # => 1.21 KB
12345.to_s(:human_size)                                 # => 12.1 KB
1234567.to_s(:human_size)                               # => 1.18 MB
1234567890.to_s(:human_size)                            # => 1.15 GB
1234567890123.to_s(:human_size)                         # => 1.12 TB
1234567.to_s(:human_size, precision: 2)                 # => 1.2 MB
483989.to_s(:human_size, precision: 2)                  # => 470 KB
1234567.to_s(:human_size, precision: 2, separator: ',') # => 1,2 MB
1234567890123.to_s(:human_size, precision: 5)           # => "1.1229 TB"
524288000.to_s(:human_size, precision: 5)               # => "500 MB"

Human-friendly format:
123.to_s(:human)                                       # => "123"
1234.to_s(:human)                                      # => "1.23 Thousand"
12345.to_s(:human)                                     # => "12.3 Thousand"
1234567.to_s(:human)                                   # => "1.23 Million"
1234567890.to_s(:human)                                # => "1.23 Billion"
1234567890123.to_s(:human)                             # => "1.23 Trillion"
1234567890123456.to_s(:human)                          # => "1.23 Quadrillion"
1234567890123456789.to_s(:human)                       # => "1230 Quadrillion"
489939.to_s(:human, precision: 2)                      # => "490 Thousand"
489939.to_s(:human, precision: 4)                      # => "489.9 Thousand"
1234567.to_s(:human, precision: 4,
                 significant: false)                   # => "1.2346 Million"
1234567.to_s(:human, precision: 1,
                 separator: ',',
                 significant: false)                   # => "1,2 Million"
# File lib/active_support/core_ext/numeric/conversions.rb, line 100
def to_formatted_s(format = :default, options = {})
  case format
  when :phone
    return ActiveSupport::NumberHelper.number_to_phone(self, options)
  when :currency
    return ActiveSupport::NumberHelper.number_to_currency(self, options)
  when :percentage
    return ActiveSupport::NumberHelper.number_to_percentage(self, options)
  when :delimited
    return ActiveSupport::NumberHelper.number_to_delimited(self, options)
  when :rounded
    return ActiveSupport::NumberHelper.number_to_rounded(self, options)
  when :human
    return ActiveSupport::NumberHelper.number_to_human(self, options)
  when :human_size
    return ActiveSupport::NumberHelper.number_to_human_size(self, options)
  else
    self.to_default_s
  end
end
until(time = ::Time.current)

Reads best with argument: 10.minutes.until(time)

Alias for: ago
week()
Alias for: weeks
weeks() click to toggle source
# File lib/active_support/core_ext/numeric/time.rb, line 54
def weeks
  ActiveSupport::Duration.new(self * 7.days, [[:days, self * 7]])
end
Also aliased as: week