NAME
Number::Format  Perl extension for formatting numbers
SYNOPSIS
use Number::Format;
my $x = new Number::Format %args;
$formatted = $x>round($number, $precision);
$formatted = $x>format_number($number, $precision, $trailing_zeroes);
$formatted = $x>format_negative($number, $picture);
$formatted = $x>format_picture($number, $picture);
$formatted = $x>format_price($number, $precision);
$formatted = $x>format_bytes($number, $precision);
$number = $x>unformat_number($formatted);
use Number::Format qw(:subs);
$formatted = round($number, $precision);
$formatted = format_number($number, $precision, $trailing_zeroes);
$formatted = format_negative($number, $picture);
$formatted = format_picture($number, $picture);
$formatted = format_price($number, $precision);
$formatted = format_bytes($number, $precision);
$number = unformat_number($formatted);
REQUIRES
Perl, version 5.8 or higher.
POSIX.pm to determine locale settings.
Carp.pm is used for some error reporting.
DESCRIPTION
These functions provide an easy means of formatting numbers in a manner suitable for displaying to the user.
There are two ways to use this package. One is to declare an object of type Number::Format, which you can think of as a formatting engine. The various functions defined here are provided as object methods. The constructor new()
can be used to set the parameters of the formatting engine. Valid parameters are:
THOUSANDS_SEP  character inserted between groups of 3 digits
DECIMAL_POINT  character separating integer and fractional parts
MON_THOUSANDS_SEP  like THOUSANDS_SEP, but used for format_price
MON_DECIMAL_POINT  like DECIMAL_POINT, but used for format_price
INT_CURR_SYMBOL  character(s) denoting currency (see format_price())
DECIMAL_DIGITS  number of digits to the right of dec point (def 2)
DECIMAL_FILL  boolean; whether to add zeroes to fill out decimal
NEG_FORMAT  format to display negative numbers (def ``x'')
KILO_SUFFIX  suffix to add when format_bytes formats kilobytes
MEGA_SUFFIX  " " " " " " megabytes
GIGA_SUFFIX  " " " " " " gigabytes
They may be specified in upper or lower case, with or without a leading hyphen (  ).
If THOUSANDS_SEP
is set to the empty string, format_number will not insert any separators.
The defaults for THOUSANDS_SEP
, DECIMAL_POINT
, MON_THOUSANDS_SEP
, MON_DECIMAL_POINT
, and INT_CURR_SYMBOL
come from the POSIX locale information (see perllocale). If your POSIX locale does not provide MON_THOUSANDS_SEP
and/or MON_DECIMAL_POINT
fields, then the THOUSANDS_SEP
and/or DECIMAL_POINT
values are used for those parameters. Formerly, POSIX was optional but this caused problems in some cases, so it is now required. If this causes you hardship, please contact the author of this package at <SwPrAwM@cpan.org> (remove "SPAM" to get correct email address) for help.
If any of the above parameters are not specified when you invoke new()
, then the values are taken from package global variables of the same name (e.g. $DECIMAL_POINT
is the default for the DECIMAL_POINT
parameter). If you use the :vars
keyword on your use Number::Format
line (see nonobjectoriented example below) you will import those variables into your namesapce and can assign values as if they were your own local variables. The default values for all the parameters are:
THOUSANDS_SEP = ','
DECIMAL_POINT = '.'
MON_THOUSANDS_SEP = ','
MON_DECIMAL_POINT = '.'
INT_CURR_SYMBOL = 'USD'
DECIMAL_DIGITS = 2
DECIMAL_FILL = 0
NEG_FORMAT = 'x'
KILO_SUFFIX = 'K'
MEGA_SUFFIX = 'M'
GIGA_SUFFIX = 'G'
Note however that when you first call one of the functions in this module without using the objectoriented interface, further setting of those global variables will have no effect on nonOO calls. It is recommended that you use the objectoriented interface instead for fewer headaches and a cleaner design.
The DECIMAL_FILL
and DECIMAL_DIGITS
values are not set by the Locale system, but are definable by the user. They affect the output of format_number()
. Setting DECIMAL_DIGITS
is like giving that value as the $precision
argument to that function. Setting DECIMAL_FILL
to a true value causes format_number()
to append zeroes to the right of the decimal digits until the length is the specified number of digits.
NEG_FORMAT
is only used by format_negative()
and is a string containing the letter 'x', where that letter will be replaced by a positive representation of the number being passed to that function. format_number()
and format_price()
utilize this feature by calling format_negative()
if the number was less than 0.
KILO_SUFFIX
, MEGA_SUFFIX
, and GIGA_SUFFIX
are used by format_bytes()
when the value is over 1024, 1024*1024, or 1024*1024*1024, respectively. The default values are "K", "M", and "G". Note: we can not do TERA because of integer overflows on 32bit systems.
The only restrictions on DECIMAL_POINT
and THOUSANDS_SEP
are that they must not be digits, must not be identical, and must each be one character. There are no restrictions on INT_CURR_SYMBOL
.
For example, a German user might include this in their code:
use Number::Format;
my $de = new Number::Format(thousands_sep => '.',
decimal_point => ',',
int_curr_symbol => 'DEM');
my $formatted = $de>format_number($number);
Or, if you prefer not to use the object oriented interface, you can do this instead:
use Number::Format qw(:subs :vars);
$THOUSANDS_SEP = '.';
$DECIMAL_POINT = ',';
$INT_CURR_SYMBOL = 'DEM';
my $formatted = format_number($number);
EXPORTS
Nothing is exported by default. To export the functions or the global variables defined herein, specify the function name(s) on the import list of the use Number::Format
statement. To export all functions defined herein, use the special tag :subs
. To export the variables, use the special tag :vars
; to export both subs and vars you can use the tag :all
.
METHODS
 new( %args )

Creates a new Number::Format object. Valid keys for %args are any of the parameters described above. Keys may be in all uppercase or all lowercase, and may optionally be preceded by a hyphen () character. Example:
my $de = new Number::Format(thousands_sep => '.', decimal_point => ',', int_curr_symbol => 'DEM');
 round($number, $precision)

Rounds the number to the specified precision. If
$precision
is omitted, the value of theDECIMAL_DIGITS
parameter is used (default value 2). Both input and output are numeric (the function uses math operators rather than string manipulation to do its job), The value of$precision
may be any integer, positive or negative. Examples:round(3.14159) yields 3.14 round(3.14159, 4) yields 3.1416 round(42.00, 4) yields 42 round(1234, 2) yields 1200
Since this is a mathematical rather than string oriented function, there will be no trailing zeroes to the right of the decimal point, and the
DECIMAL_POINT
andTHOUSANDS_SEP
variables are ignored. To format your number using theDECIMAL_POINT
andTHOUSANDS_SEP
variables, useformat_number()
instead.  format_number($number, $precision, $trailing_zeroes)

Formats a number by adding
THOUSANDS_SEP
between each set of 3 digits to the left of the decimal point, substitutingDECIMAL_POINT
for the decimal point, and rounding to the specified precision usinground()
. Note that$precision
is a maximum precision specifier; trailing zeroes will only appear in the output if$trailing_zeroes
is provided, or the parameterDECIMAL_FILL
is set, with a value that is true (not zero, undef, or the empty string). If$precision
is omitted, the value of theDECIMAL_DIGITS
parameter (default value of 2) is used.If the value is too large or great to work with as a regular number, but instead must be shown in scientific notation, returns that number in scientific notation without further formatting.
Examples:
format_number(12345.6789) yields '12,345.68' format_number(123456.789, 2) yields '123,456.79' format_number(1234567.89, 2) yields '1,234,567.89' format_number(1234567.8, 2) yields '1,234,567.8' format_number(1234567.8, 2, 1) yields '1,234,567.80' format_number(1.23456789, 6) yields '1.234568' format_number("0.000020000E+00", 7);' yields '2e05'
Of course the output would have your values of
THOUSANDS_SEP
andDECIMAL_POINT
instead of ',' and '.' respectively.  format_negative($number, $picture)

Formats a negative number. Picture should be a string that contains the letter
x
where the number should be inserted. For example, for standard negative numbers you might use ``x
'', while for accounting purposes you might use ``(x)
''. If the specified number begins with a ``'' character, that will be removed before formatting, but formatting will occur whether or not the number is negative.  format_picture($number, $picture)

Returns a string based on
$picture
with the#
characters replaced by digits from$number
. If the length of the integer part of $number is too large to fit, the#
characters are replaced with asterisks (*
) instead. Examples:format_picture(100.023, 'USD ##,###.##') yields 'USD 100.02' format_picture(1000.23, 'USD ##,###.##') yields 'USD 1,000.23' format_picture(10002.3, 'USD ##,###.##') yields 'USD 10,002.30' format_picture(100023, 'USD ##,###.##') yields 'USD **,***.**' format_picture(1.00023, 'USD #.###,###') yields 'USD 1.002,300'
The comma (,) and period (.) you see in the picture examples should match the values of
THOUSANDS_SEP
andDECIMAL_POINT
, respectively, for proper operation. However, theTHOUSANDS_SEP
characters in$picture
need not occur every three digits; the only use of that variable by this function is to remove leading commas (see the first example above). There may not be more than one instance ofDECIMAL_POINT
in$picture
.The value of
NEG_FORMAT
is used to determine how negative numbers are displayed. The result of this is that the output of this function my have unexpected spaces before and/or after the number. This is necessary so that positive and negative numbers are formatted into a space the same size. If you are only using positive numbers and want to avoid this problem, set NEG_FORMAT to "x".  format_price($number, $precision)

Returns a string containing
$number
formatted similarly toformat_number()
, except that the decimal portion may have trailing zeroes added to make it be exactly$precision
characters long, and the currency string will be prefixed.If the
INT_CURR_SYMBOL
attribute of the object is the empty string, no currency will be added.If
$precision
is not provided, the default of 2 will be used. Examples:format_price(12.95) yields 'USD 12.95' format_price(12) yields 'USD 12.00' format_price(12, 3) yields '12.000'
The third example assumes that
INT_CURR_SYMBOL
is the empty string.  format_bytes($number, $options)
 format_bytes($number, $precision) # deprecated

Returns a string containing
$number
formatted similarly toformat_number()
, except that large numbers may be abbreviated by adding$KILO_SUFFIX
,$MEGA_SUFFIX
, or$GIGA_SUFFIX
. Negative values will result in an error.The second parameter can be either a reference to a hash that sets options, or a number. Using a number here is deprecated; older versions of Number::Format only allowed a numeric value. New code should use a hash reference instead. If it is a number this sets the value of the "precision" option.
Valid options are:
 precision

Set the precision for displaying numbers. If not provided, a default of 2 will be used. Examples:
format_bytes(12.95) yields '12.95' format_bytes(2048) yields '2K' format_bytes(9999999) yields '9.54M'
 unit

Sets the default units used for the results. The default is to determine this automatically in order to minimize the length of the string. In other words, numbers greater than or equal to 1024 will be divided by 1024 and
$KILO_SUFFIX
added; if greater than or equal to 1048576 (1024*1024), it will be divided by 1048576 and "M" appended to the end; etc.However if a value is given for
unit
it will use that value instead. Acceptable values forunit
are: 'giga', 'mega', 'kilo', 'none', or 'auto'. These may be abbreviated to their first letters 'g', 'm', 'k', 'n', or 'a'; they may be given in upper or lowercase letters. For example:format_bytes(1048576, { units => 'K'}) yields '1,024K' instead of '1M'
Using 'none' as the unit blocks all unit conversion, and the function simply returns the result of format_number($number, $precision). The default behavior can be obtained by specifying 'auto'.
Note that the valid values to this option do not vary even when the
$GIGA_SUFFIX
,$MEGA_SUFFIX
, and$KILO_SUFFIX
variables have been changed.  base

Sets the number at which the
$KILO_SUFFIX
is added. Default is 1024. Set to any value; the only other useful value is probably 1000, as hard disk manufacturers use that number to make their disks sound bigger than they really are.
 unformat_number($formatted)

Converts a string as returned by
format_number()
,format_price()
, orformat_picture()
, and returns the corresponding value as a numeric scalar. Returnsundef
if the number does not contain any digits. Examples:unformat_number('USD 12.95') yields 12.95 unformat_number('USD 12.00') yields 12 unformat_number('foobar') yields undef unformat_number('1234567@.8') yields 1234567.8
The value of
DECIMAL_POINT
is used to determine where to separate the integer and decimal portions of the input. All other nondigit characters, including but not limited toINT_CURR_SYMBOL
andTHOUSANDS_SEP
, are removed.If the number matches the pattern of
NEG_FORMAT
or there is a ``'' character before any of the digits, then a negative number is returned.If the number ends with the
KILO_SUFFIX
orMEGA_SUFFIX
characters, then the number returned will be multiplied by 1024 or 1024*1024 as appropriate.
BUGS
No known bugs at this time. Report bugs using the CPAN request tracker at https://rt.cpan.org/NoAuth/Bugs.html?Dist=NumberFormat or by email to the author.
AUTHOR
William R. Ward, SwPrAwM@cpan.org (remove "SPAM" before sending email, leaving only my initials)
SEE ALSO
perl(1).