NAME
LooksLike  See if a number looks like a number, integer, numeric, infinity, notanumber, zero, nonzero, positive, negative, even, or odd.
SYNOPSIS
use LooksLike;
printf( "%5s%6s%3s%3s%3s%7s%4s%7s%3s%3s%4s%3s\n",
"",
qw(
Number Inf NaN
Int Numeric
Zero NonZero
Pos Neg
Even Odd
)
);
for ( qw( inf 1 .23 0 0.0 0e0 .23 1 inf nan ),
1e9999, 1, 0.23, 0, 0.23, 1e9999, 1e9999/1e9999 )
{
printf( "%5s%6d%3d%3d%3d%7d%4d%7d%3d%3d%4d%3d\n",
$_,
0+ LooksLike::number(),
0+ LooksLike::infinity(),
0+ LooksLike::nan(),
0+ LooksLike::integer(),
0+ LooksLike::numeric(),
0+ LooksLike::zero(),
0+ LooksLike::nonzero(),
0+ LooksLike::positive(),
0+ LooksLike::negative(),
0+ LooksLike::even(),
0+ LooksLike::odd(),
);
}
# NumberInfNaNIntNumericZeroNonZeroPosNegEvenOdd
# inf 1 1 0 0 0 0 1 0 1 0 0
# 1 1 0 0 1 1 0 1 0 1 0 1
# .23 1 0 0 0 1 0 1 0 1 0 0
# 0 1 0 0 1 1 1 0 0 0 1 0
# 0.0 1 0 0 0 1 1 0 0 0 0 0
# 0e0 1 0 0 0 1 1 0 0 0 0 0
# .23 1 0 0 0 1 0 1 1 0 0 0
# 1 1 0 0 1 1 0 1 1 0 0 1
# inf 1 1 0 0 0 0 1 1 0 0 0
# nan 1 0 1 0 0 0 0 0 0 0 0
# inf 1 1 0 0 0 0 1 0 1 0 0
# 1 1 0 0 1 1 0 1 0 1 0 1
# 0.23 1 0 0 0 1 0 1 0 1 0 0
# 0 1 0 0 1 1 1 0 0 0 1 0
# 0.23 1 0 0 0 1 0 1 1 0 0 0
# inf 1 1 0 0 0 0 1 1 0 0 0
# nan 1 0 1 0 0 0 1 0 0 0 0
DESCRIPTION
The module Scalar::Util has a useful function called looks_like_number
, but it doesn't tell you what kind of number it is, and it also considers NaN
and Infinity
as numbers, which isn't always what you want. This attempts to be a lot more flexible about letting you ask what kind of number you have, and lets you decide how to handle that.
The module asks Perl about the value being held in the scalar, and if it has an integer or numeric value, it uses that for comparisons, otherwise it performs the test with a regular expression. This methodology should be more efficient for values that have been converted to a numeric value.
All of the functions will use $_
if there is no parameter given.
Regexp Only Functions
The following functions work only on strings, as evaluating them numerially doesn't make sense: binary()
, octal()
, hex()
, decimal()
, and grok_number()
.
Numeric or Regexp Functions
The following functions operate on the numeric values, if they exist, otherwise they fall back to the regular expression equivalent: number()
, integer()
, numeric()
, comparable()
, infinity()
, nan()
, zero()
, nonzero()
, positive()
, negative()
, even()
, and odd()
.
Regular Expressions
There are numerous regular expressions available, if you'd like to search for numbers of a particular format: $Binary
, $Octal
, $Hex
, $Decimal
, $Infinity
, $NaN
, $Integer
, $Numeric
, $Zero
, $Nonzero
, $Positive
, $Negative
, $Even
, and $Odd
.
VARIABLES
$Binary
A zero character, followed by a "B" (ignoring case), followed by a series of zero and one characters
$Octal
A zero character, followed by a series of zero through seven characters.
$Hex
A zero character, followed by an "X" (ignoring case), followed by a series of zero through nine characters and/or "A" through "F" characters (ignoring case).
$Decimal
A series of zero through nine characters, possibly separated by a single period.
$Infinity
The case insensitive words "inf" and "infinity".
Perl version 5.22 and greater recognize a larger set of representations that include "1.#INF"
, "1.#Infinity"
, "1.#inf00"
, among others.
$NaN
The case insensitive words "nan".
Perl version 5.22 and greater recognize a larger set of representations that include "nanq"
, "nans"
, "qnan"
, "snan"
, "1.#nans"
, "1.#qnan"
, "1.#nan(123)"
, "1.#nan(0x45)"
, among others.
$Integer
A series of digits.
$Numeric
Anything which would be recognized as an integer or floating point number.
$Zero
Anything which would be regarded as equal to 0.
$NonZero
Anything which looks like a number, but is not 0.
$Positive
Any number that would compare to greater than 0.
$Negative
Any number that would compare to less than 0.
$Even
Any integer which would divide evenly by 2.
$Odd
Any integer which would divde oddly by 2.
%representation
The hash used by "representation( $_ ; %representation )" to format various numeric representations. Has three fields:
infinity

How positive infinity should be represented. Defaults to
inf
. infinity

How negative infinity should be represented. Defaults to
inf
. nan

How notanumber should be represented. Defaults to
nan
.
FUNCTIONS
binary($_)
Returns true if the string starts with 0b
and finishes with a series of 0
and 1
digits.
octal($_)
Returns true if the string starts with 0
and finishes with a series of 0
through 7
digits.
hex($_)
Returns true if the string starts with 0x
and finishes with a series of 0
through 9
or a
through f
digits.
decimal($_)
Returns true if the string looks like a floating point number without the E
exponent portion.
grok_number($_)
A pure Perl representation of the internal function of the same name. Returns 6 items:
 sign

Any leading
+
or
sign, or the empty string if there was no leading sign.  number

The whole part of the number, before the dot, if there is one. Could be the empty string. If it was an unsuccesful parse, could be
undef
. Could also be some form ofNaN
,IND
,inf
, orInfinity
.  fraction

The fractional part of the number, after the dot, if there is one. Could be the empty string or
undef
.It should not be possible for the number and fraction to both be the empty string.
 exponent sign

Any leading
+
or
sign in the exponent, or the empty string if there was no leading sign. Could be the empty string orundef
.  exponent number

The digits representing the exponent. Could be
undef
.  excess

If there was any part of the string that remained unparsed, it is returned as this substring. In a complete parse, it is the empty string.
infinity($_)
Returns a true value if the value represents some form of infinity. The strings infinity
and inf
are both valid (caseinsensitively).
nan($_)
Returns a true value if the value represents some form of notanumber (NaN
). The string nan
is valid (caseinsensitively).
integer($_)
Returns true if the value is a series of ASCII digits 0
through 9
. Does not guarantee that the number will fit into any number of bits.
numeric($_)
Returns true for any representation of a floating point number, which includes integers. It does not include the representations of inf
and nan
.
comparable($_)
Returns true for any representation of a number that can be compared to another number. In other words: true for infinity, integers, and floating point numbers; false for notanumber, and anything else.
number($_)
Equivalent to "looks_like_number" in Scalar::Util, and returns true for all representations of infinity, notanumber, integer, and floating point numbers.
zero($_)
Returns true for any value that would be interepreted equal (==
) to 0.
nonzero($_)
Returns true for any value that would be interepreted not equal (!=
) to 0.
positive($_)
Returns true for any value that would be interpreted as greater than (>
) 0.
negative($_)
Returns true for any value that would be interpreted as less than (<
) 0.
even($_)
Returns true for any integer that would have no remainder when modulused with 2.
odd($_)
Returns true for any integer that would have a remainder when modulused with 2.
representation( $_ ; %representation )
Condense the large set of representations for infinity and notanumber to a simple set. Pass in a value (or use $_
if nothing is passed in), and if it's something that matches positive infinity, negative infinity, or notanumber, then format it as the %representation
hash indicates.
The keys and values to override the %representation
hash can be passed in, and the values will be used in place of the defaults.
Since v0.20.056.
TODO
Nothing, my code is perfect. Please let me know if you think that statement is incorrect.
BUGS
Please report any bugs or feature requests on the bugtracker website https://github.com/rkleemann/LooksLike/issues
When submitting a bug or request, please include a testfile or a patch to an existing testfile that illustrates the bug or desired feature.
VERSION
This document describes version v0.20.060 of this module.
AUTHOR
Bob Kleemann <bobk@cpan.org>
COPYRIGHT AND LICENSE
This software is Copyright (c) 2020 by Bob Kleemann.
This is free software, licensed under:
The Artistic License 2.0 (GPL Compatible)