module ActiveSupport::NumberHelper

# => "$1,234,567,891"
number_to_currency(1234567890.50, precision: 0, round_mode: :up)
# => "$1,234,567,890.5"
number_to_currency(1234567890.50, strip_insignificant_zeros: true)
# => "1234567890,50 £"
number_to_currency(1234567890.50, unit: '£', separator: ',', delimiter: '', format: '%n %u')
# => "£1234567890,50"
number_to_currency(1234567890.50, unit: '£', separator: ',', delimiter: '')
# => "($1,234,567,890.50)"
number_to_currency(-1234567890.50, negative_format: '(%u%n)')
# => "$0"
number_to_currency(-0.456789, precision: 0)

number_to_currency('123a456') # => "$123a456"
number_to_currency(1234567890.506, locale: :fr) # => "1 234 567 890,51 €"
number_to_currency(1234567890.506, precision: 3) # => "$1,234,567,890.506"
number_to_currency(1234567890.506) # => "$1,234,567,890.51"
number_to_currency(1234567890.50) # => "$1,234,567,890.50"

==== Examples

+false+).
insignificant zeros after the decimal separator (defaults to
* :strip_insignificant_zeros - If +true+ removes
absolute value of the number.
than :format, except %n is here the
number given by :format). Accepts the same fields
numbers (defaults to prepending a hyphen to the formatted
* :negative_format - Sets the format for negative
currency, and %n for the number.
(defaults to "%u%n"). Fields are %u for the
* :format - Sets the format for non-negative numbers
to ",").
* :delimiter - Sets the thousands delimiter (defaults
(defaults to ".").
* :separator - Sets the separator between the units
(defaults to "$").
* :unit - Sets the denomination of the currency
(defaults to :default. See BigDecimal::mode)
* :round_mode - Determine how rounding is performed
to 2).
* :precision - Sets the level of precision (defaults
(defaults to current locale).
* :locale - Sets the locale to be used for formatting

==== Options

using a library capable of currency conversion.
may want to specify a constant :locale option or consider
this helper. If your application will ever support multiple locales, you
also be able to change the relative value of the currency displayed with
is performed. If the user is given a way to change their locale, they will
unless otherwise specified in the provided options. No currency conversion
The currency unit and number formatting of the current locale will be used

can customize the format in the +options+ hash.
Formats a +number+ into a currency string (e.g., $13.65). You

def number_to_currency(number, options = {})
  NumberToCurrencyConverter.convert(number, options)
end

# => "1,23,456.78"
delimiter_pattern: /(\d+?)(?=(\d\d)+(\d)(?!\d))/)
number_to_delimited("123456.78",
# => "98 765 432,98"
number_to_delimited(98765432.98, delimiter: ' ', separator: ',')
number_to_delimited('112a') # => "112a"
number_to_delimited(12345678.05, locale: :fr) # => "12 345 678,05"
number_to_delimited(12345678.05, separator: ' ') # => "12,345,678 05"
number_to_delimited(12345678, delimiter: ',') # => "12,345,678"
number_to_delimited(12345678, delimiter: '.') # => "12.345.678"
number_to_delimited(12345678.05) # => "12,345,678.05"
number_to_delimited('123456') # => "123,456"
number_to_delimited(12345678) # => "12,345,678"

==== Examples

like INR.
deriving the placement of delimiter. Helpful when using currency formats
* :delimiter_pattern - Sets a custom regular expression used for
fractional and integer digits (defaults to ".").
* :separator - Sets the separator between the
to ",").
* :delimiter - Sets the thousands delimiter (defaults
(defaults to current locale).
* :locale - Sets the locale to be used for formatting

==== Options

hash.
(e.g., 12,324). You can customize the format in the +options+
Formats a +number+ with grouped thousands using +delimiter+

def number_to_delimited(number, options = {})
  NumberToDelimitedConverter.convert(number, options)
end

number_to_human(0.34, units: :distance) # => "34 centimeters"
number_to_human(1, units: :distance) # => "1 meter"
number_to_human(343, units: :distance, precision: 1) # => "300 meters"
number_to_human(54393498000, units: :distance) # => "54.4 gazillion-distance"
number_to_human(54393498, units: :distance) # => "54400 kilometers"
number_to_human(543934, units: :distance) # => "544 kilometers"

Then you could do:

billion: "gazillion-distance"
other: "kilometers"
one: "kilometer"
thousand:
other: "meters"
one: "meter"
unit:
other: "centimeters"
one: "centimeter"
centi:
distance:

If in your I18n locale you have:

number_to_human(500000, units: { unit: 'ml', thousand: 'lt' }) # => "500 lt"
You can also use your own custom unit quantifiers:

==== Custom Unit Quantifiers

number_to_human(12.00001, strip_insignificant_zeros: false) # => "12.0"
number_to_human(12.00001) # => "12"

+false+ to change that):
out by default (set :strip_insignificant_zeros to
Non-significant zeros after the decimal separator are stripped

number_to_human(12345012345, significant: false) # => "12.345 Billion"
number_to_human(500000000, precision: 5) # => "500 Million"

significant: false) # => "1,2 Million"
separator: ',',
number_to_human(1234567, precision: 1,
significant: false) # => "1.2346 Million"
number_to_human(1234567, precision: 4,
, round_mode: :down) # => "480 Thousand"
number_to_human(489939, precision: 2
number_to_human(489939, precision: 4) # => "489.9 Thousand"
number_to_human(489939, precision: 2) # => "490 Thousand"
number_to_human(1234567890123456789) # => "1230 Quadrillion"
number_to_human(1234567890123456) # => "1.23 Quadrillion"
number_to_human(1234567890123) # => "1.23 Trillion"
number_to_human(1234567890) # => "1.23 Billion"
number_to_human(1234567) # => "1.23 Million"
number_to_human(12345) # => "12.3 Thousand"
number_to_human(1234) # => "1.23 Thousand"
number_to_human(123) # => "123"

==== Examples

* %n - The number
* %u - The quantifier (ex.: 'thousand')
(defaults to "%n %u"). The field types are:
* :format - Sets the format of the output string
:pico, :femto
:mili, :micro, :nano,
* *fractionals*: :deci, :centi,
:quadrillion
:billion, :trillion,
:hundred, :thousand, :million,
* *integers*: :unit, :ten,
might have the following keys:
string containing an i18n scope where to find this hash. It
* :units - A Hash of unit quantifier names. Or a
+true+)
insignificant zeros after the decimal separator (defaults to
* :strip_insignificant_zeros - If +true+ removes
to "").
* :delimiter - Sets the thousands delimiter (defaults
fractional and integer digits (defaults to ".").
* :separator - Sets the separator between the
digits (defaults to +true+)
of significant_digits. If +false+, the number of fractional
* :significant - If +true+, precision will be the number
(defaults to :default. See BigDecimal::mode)
* :round_mode - Determine how rounding is performed
(defaults to 3).
* :precision - Sets the precision of the number
(defaults to current locale).
* :locale - Sets the locale to be used for formatting

==== Options

(centi, deci, mili, etc).
define a wide range of unit quantifiers, even fractional ones
kilometers", 0.150 becomes "150 milliliters", etc). You may
to use other decimal units (e.g.: 1500 becomes "1.5
You can also define your own unit-quantifier names if you want

size.
See number_to_human_size if you want to print a file

(and too hard to read).
Billion"). This is useful for numbers that can get very large
is more readable by humans (e.g.: 1200000000 becomes "1.2
Pretty prints (formats and approximates) a number in a way it

def number_to_human(number, options = {})
  NumberToHumanConverter.convert(number, options)
end

number_to_human_size(524288000, precision: 5) # => "500 MB"
number_to_human_size(1234567890123, precision: 5) # => "1.1228 TB"
number_to_human_size(1234567, precision: 2, separator: ',') # => "1,2 MB"
number_to_human_size(483989, precision: 2, round_mode: :up) # => "480 KB"
number_to_human_size(483989, precision: 2) # => "470 KB"
number_to_human_size(1234567, precision: 2) # => "1.2 MB"
number_to_human_size(1234567890123456789) # => "1.07 EB"
number_to_human_size(1234567890123456) # => "1.1 PB"
number_to_human_size(1234567890123) # => "1.12 TB"
number_to_human_size(1234567890) # => "1.15 GB"
number_to_human_size(1234567) # => "1.18 MB"
number_to_human_size(12345) # => "12.1 KB"
number_to_human_size(1234) # => "1.21 KB"
number_to_human_size(123) # => "123 Bytes"

==== Examples

+true+)
insignificant zeros after the decimal separator (defaults to
* :strip_insignificant_zeros - If +true+ removes
to "").
* :delimiter - Sets the thousands delimiter (defaults
fractional and integer digits (defaults to ".").
* :separator - Sets the separator between the
digits (defaults to +true+)
of significant_digits. If +false+, the number of fractional
* :significant - If +true+, precision will be the number
(defaults to :default. See BigDecimal::mode)
* :round_mode - Determine how rounding is performed
(defaults to 3).
* :precision - Sets the precision of the number
(defaults to current locale).
* :locale - Sets the locale to be used for formatting

==== Options

generic number.
See number_to_human if you want to pretty-print a

customize the format in the +options+ hash.
method is useful for reporting file sizes to users. You can
representation (e.g., giving it 1500 yields 1.46 KB). This
Formats the bytes in +number+ into a more understandable

def number_to_human_size(number, options = {})
  NumberToHumanSizeConverter.convert(number, options)
end

number_to_percentage(302.24398923423, precision: 5, round_mode: :down) # => "302.24398%"
number_to_percentage(100, format: '%n %') # => "100.000 %"
number_to_percentage('98a') # => "98a%"
number_to_percentage(1000, precision: nil) # => "1000%"
number_to_percentage(1000, locale: :fr) # => "1000,000%"
number_to_percentage(302.24398923423, precision: 5) # => "302.24399%"
number_to_percentage(1000, delimiter: '.', separator: ',') # => "1.000,000%"
number_to_percentage(100, precision: 0) # => "100%"
number_to_percentage('98') # => "98.000%"
number_to_percentage(100) # => "100.000%"

==== Examples

string The number field is %n (defaults to "%n%").
* :format - Specifies the format of the percentage
+false+).
insignificant zeros after the decimal separator (defaults to
* :strip_insignificant_zeros - If +true+ removes
to "").
* :delimiter - Sets the thousands delimiter (defaults
fractional and integer digits (defaults to ".").
* :separator - Sets the separator between the
digits (defaults to +false+).
of significant_digits. If +false+, the number of fractional
* :significant - If +true+, precision will be the number
(defaults to :default. See BigDecimal::mode)
* :round_mode - Determine how rounding is performed
(defaults to 3). Keeps the number's precision if +nil+.
* :precision - Sets the precision of the number
(defaults to current locale).
* :locale - Sets the locale to be used for formatting

==== Options

customize the format in the +options+ hash.
Formats a +number+ as a percentage string (e.g., 65%). You can

def number_to_percentage(number, options = {})
  NumberToPercentageConverter.convert(number, options)
end

# => "133-1234-5678"
number_to_phone(13312345678, pattern: /(\d{3})(\d{4})(\d{4})$/)
# => "(755) 6123-4567"
number_to_phone(75561234567, pattern: /(\d{1,4})(\d{4})(\d{4})$/, area_code: true)

# => "+1.123.555.1234 x 1343"
number_to_phone(1235551234, country_code: 1, extension: 1343, delimiter: '.')

number_to_phone('123a456') # => "123a456"
number_to_phone(1235551234, country_code: 1) # => "+1-123-555-1234"
number_to_phone(1235551234, area_code: true, extension: 555) # => "(123) 555-1234 x 555"
number_to_phone(1235551234, delimiter: ' ') # => "123 555 1234"
number_to_phone(1235551234, area_code: true) # => "(123) 555-1234"
number_to_phone(1235551234) # => "123-555-1234"
number_to_phone('5551234') # => "555-1234"
number_to_phone(5551234) # => "555-1234"

==== Examples
groups with the custom regexp to override the default format.
* :pattern - Specifies how the number is divided into three
number.
* :country_code - Sets the country code for the phone
end of the generated number.
* :extension - Specifies an extension to add to the
(defaults to "-").
* :delimiter - Specifies the delimiter to use
* :area_code - Adds parentheses around the area code.

==== Options

123-9876). You can customize the format in the +options+ hash.
Formats a +number+ into a phone number (US by default e.g., (555)

def number_to_phone(number, options = {})
  NumberToPhoneConverter.convert(number, options)
end

# => "1.111,23"
number_to_rounded(1111.2345, precision: 2, separator: ',', delimiter: '.')
number_to_rounded(389.32314, precision: 4, significant: true) # => "389.3"

# => "13"
number_to_rounded(13, precision: 5, significant: true, strip_insignificant_zeros: true)

number_to_rounded(111.234, locale: :fr) # => "111,234"
number_to_rounded(389.32314, precision: 0, round_mode: :up) # => "390"
number_to_rounded(13, precision: nil) # => "13"
number_to_rounded(13, precision: 5, significant: true) # => "13.000"
number_to_rounded(111.2345, precision: 1, significant: true) # => "100"
number_to_rounded(111.2345, significant: true) # => "111"
number_to_rounded(389.32314, precision: 0) # => "389"
number_to_rounded(13, precision: 5) # => "13.00000"
number_to_rounded(111.2345, precision: 2) # => "111.23"
number_to_rounded(111.2345) # => "111.235"

==== Examples

+false+).
insignificant zeros after the decimal separator (defaults to
* :strip_insignificant_zeros - If +true+ removes
to "").
* :delimiter - Sets the thousands delimiter (defaults
fractional and integer digits (defaults to ".").
* :separator - Sets the separator between the
digits (defaults to +false+).
of significant_digits. If +false+, the number of fractional
* :significant - If +true+, precision will be the number
(defaults to :default. See BigDecimal::mode)
* :round_mode - Determine how rounding is performed
(defaults to 3). Keeps the number's precision if +nil+.
* :precision - Sets the precision of the number
(defaults to current locale).
* :locale - Sets the locale to be used for formatting

==== Options

You can customize the format in the +options+ hash.
+:significant+ is +false+, and 5 if +:significant+ is +true+).
:precision (e.g., 112.32 has a precision of 2 if
Formats a +number+ with the specified level of

def number_to_rounded(number, options = {})
  NumberToRoundedConverter.convert(number, options)
end