Determine if a string is numeric: Difference between revisions

Create a boolean function which takes in a string and tells whether it is a numeric string (floating point and negative numbers included) in the syntax the language uses for numeric literals or numbers converted from strings.

 

=={{header|ActionScript}}==

{

return !isNaN(parseInt(num));

 

=={{header|Ada}}==

The first file is the package interface containing the declaration of the Is_Numeric function.

function Is_Numeric (Item : in String) return Boolean;

The second file is the package body containing the implementation of the Is_Numeric function.

function Is_Numeric (Item : in String) return Boolean is

Dummy : Float;

return False;

end Is_Numeric;

The last file shows how the Is_Numeric function can be called.

with Numeric_Tests; use Numeric_Tests;

 

Put_Line(S2 & " results in " & Boolean'Image(Is_Numeric(S2)));

Put_Line(S3 & " results in " & Boolean'Image(Is_Numeric(S3)));

152 results in TRUE

-3.1415926 results in TRUE

Foo123 results in FALSE

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}

BOOL out := TRUE;

PROC call back false = (REF FILE f)BOOL: (out:= FALSE; TRUE);

))

)

<pre>

152 results in T

Foo123 results in F

</pre>

 

=={{header|APL}}==

{{works with|Dyalog APL}}

 

=={{header|AutoHotkey}}==

AutoHotkey has no explicitly defined variable types. A variable containing only digits (with an optional decimal point) is automatically interpreted as a number when a math operation or comparison requires it.

Loop, Parse, list, %A_Space%

MsgBox,% IsNumeric(A_LoopField)

}

 

 

=={{header|AWK}}==

The following function uses the fact that non-numeric strings in AWK are treated as having the value 0 when used in arithmetics, but not in comparison:

 

=={{header|BASIC}}==

20 IF R THEN PRINT "Is num" ELSE PRINT"Not num"

99 END

1000 T1=VAL(S$):T1$=STR$(T1)

1010 R=T1$=S$ OR T1$=" "+S$

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

READ N$

IF FN_isanumber(N$) THEN

IF LEFT$(A$,1) = "0" THEN = TRUE

= FALSE

<pre>'PI' is NOT a number

'0123' is a number

'12+3' is NOT a number

'end' is NOT a number</pre>

=={{header|Bracmat}}==

To check whether a string is a number, a fraction or an integer, use the patterns <code>#</code>, <code>/</code> and <code>~/#</code> ("not a fraction and yet a number"). In the pattern matching examples below (which can be typed in at the Bracmat prompt) <code>F</code> denotes 'failure' and <code>S</code> denotes 'success'.

 

F

 

 

80000000000:~/#

F

 

 

@("0.0000":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))

 

 

 

=={{header|C}}==

Returns true (non-zero) if character-string parameter represents a signed or unsigned floating-point number. Otherwise returns false (zero).

 

#include <stdlib.h>

return *p == '\0';

 

=={{header|C++}}==

 

using namespace std;

return ( iss.rdbuf()->in_avail() == 0 );

}

 

bool isNumeric( const char* pszInput, int nNumberBase )

{

return (input.find_first_not_of(base.substr(0, nNumberBase)) == string::npos);

}

 

 

 

=={{header|Clojure}}==

(if-let [s (seq s)]

(let [s (if (= (first s) \-) (next s) s)

s (if (= (first s) \.) (next s) s)

s (drop-while #(Character/isDigit %) s)]

This works with any sequence of characters, not just Strings, e.g.:

 

 

 

=={{header|CoffeeScript}}==

The isFinite function is built into JavaScript, so we don't need to create our own function in CoffeeScript.

console.log (isFinite(s) for s in [5, "5", "-5", "5", "5e5", 0]) # all true

console.log (isFinite(s) for s in [NaN, "fred", "###"]) # all false

 

=={{header|ColdFusion}}==

Adobe's ColdFusion

 

TestValue: <cfoutput>#TestValue#</cfoutput><br>

<cfif isNumeric(TestValue)>

<cfelse>

is NOT Numeric.

 

=={{header|Common Lisp}}==

If the input may be relied upon to not be especially malicious, then it may be ''read'' and the result checked for being a number.

(let ((*read-eval* nil))

<code>ignore-errors</code> here handles returning nil in case the input is invalid rather than simply non-numeric.

 

However, <code>read</code>[<code>-from-string</code>] has the side effect of interning any symbols encountered, and can have memory allocation larger than the input size (due to read syntax such as <code>#*</code>, which takes a length). The [http://www.cliki.net/PARSE-NUMBER <code>parse-number</code>] library provides a numbers-only equivalent of <code>read</code>.

 

=={{header|D}}==

 

return true;

}

 

void main() {

{{out}}

 

=={{header|Delphi}}==

This simple function is a wrapper around a built-in Delphi function

 

function IsNumericString(const inStr: string): Boolean;

var

Result := TryStrToFloat(inStr,i);

end;

 

This console application tests the function:

 

program isNumeric;

 

end.

 

 

<pre>

123 is numeric

</pre>

 

 

try {

<import:java.lang.makeDouble>.valueOf(specimen)

return false

}

 

=={{header|Erlang}}==

Erlang doesn't come with a way to say if a string represents a numeric value or not, but does come with the built-in function <tt>is_number/1</tt>, which will return true if the argument passed is either an integer or a float. Erlang also has two functions to transform a string to either a floating number or an integer, which will be used in conjunction with <tt>is_number/1</tt>.

 

Float = (catch erlang:list_to_float(L)),

Int = (catch erlang:list_to_integer(L)),

 

 

 

function is_numeric(sequence s)

val = value(s)

return val[1]=GET_SUCCESS and atom(val[2])

 

=={{header|F_Sharp|F#}}==

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

The 'fromStr' methods return a parsed number or given an error. The 'false' tells each method to return null if the string does not parse as a number of given type, otherwise, the 'fromStr' method throws an exception.

 

class Main

{

}

}

 

<pre>

For '2': true

</pre>

 

 

=={{header|Forth}}==

{{works with|gforth|0.6.2}}

2dup snumber? ?dup if \ not standard, but >number is more cumbersome to use

0< if

hex

s" beef" is-numeric \ beef as integer = BEEF

 

=={{header|Fortran}}==

IMPLICIT NONE

CHARACTER(len=*), INTENT(IN) :: string

READ(string,*,IOSTAT=e) x

is_numeric = e == 0

 

=={{header|Go}}==

 

_, err := strconv.ParseFloat(s, 64)

return err == nil

 

=={{header|Groovy}}==

Use the positional parser in java.text.NumberFormat. If, after parsing, the parse position is at the end of the string, we can deduce that the entire string was a valid number.

def formatter = java.text.NumberFormat.instance

def pos = [0] as java.text.ParsePosition

// them the whole string was numeric

pos.index == it.size()

 

Test Program:

println isNumeric('-.555')

println isNumeric('1,000,000')

println isNumeric(' 1 1 1 1 ')

 

<pre>true

true

 

=={{header|Haskell}}==

This function is not particularly useful in a statically typed language. Instead, one would just attempt to convert the string

to the desired type with ''read'' or ''reads'', and handle parsing failure appropriately.

The task doesn't define which strings are considered "numeric", so we do Integers and Doubles, which should catch the most common cases (including hexadecimal 0x notation):

 

[(_, "")] -> True

_ -> False

 

isNumeric :: String -> Bool

 

One can easily add ''isRational'', ''isComplex'' etc. following the same pattern.

Another way would be to use the Data.Char module, allowing code such as:

 

isDigit selects ASCII digits i.e. '0'..'9'

isOctDigit selects '0'..'7'

 

so read s::Int (for instance) could be reliably used if string s passed these tests.

 

=={{header|HicEst}}==

isNumeric("1001") ! 27 = 1 1 0 1 1 0

isNumeric("123") ! 26 = 0 1 0 1 1 0

isNumeric = (Lbin==L) + 2*(Lint==L) + 4*(Lflt==L) + 8*(Loct==L) + 16*(Lhex==L) + 32*(Lsci==L)

ENDIF

 

=={{header|Icon}} and {{header|Unicon}}==

The code writes a printable image of x whatever type it is and a statement about whether it is numeric or not. Icon and Unicon use success and failure instead of boolean functions, numeric(x) is built-in and returns x or fails.

write(image(x), if numeric(x) then " is numeric." else " is not numeric")

 

=={{header|IDL}}==

on_ioerror, false

test = double(input)

return, 1

false: return, 0

 

Could be called like this:

 

; ==> yes

if isnumeric('picklejuice') then print, 'yes' else print, 'no'

 

=={{header|J}}==

isNumericScalar=: 1 -: isNumeric

TXT=: ,&' a scalar numeric value.' &.> ' is not';' represents'

Examples of use:

1

isNumeric '152 -3.1415926 Foo123'

0

sayIsNumericScalar '-3.1415926'

 

=={{header|Java}}==

It's generally bad practice in Java to rely on an exception being thrown since exception handling is relatively expensive. If non-numeric strings are common, you're going to see a huge performance hit.

try {

Integer.parseInt(input);

return false;

}

 

Alternative 1 : Check that each character in the string is number. Note that this will only works for integers.

 

if (s == null || s.isEmpty()) return false;

for (int x = 0; x < s.length(); x++) {

}

return true; // valid

 

Alternative 2 : use a regular expression (a more elegant solution).

 

return inputData.matches("[-+]?\\d+(\\.\\d+)?");

 

Alternative 3 : use the positional parser in the java.text.NumberFormat object (a more robust solution). If, after parsing, the parse position is at the end of the string, we can deduce that the entire string was a valid number.

 

NumberFormat formatter = NumberFormat.getInstance();

ParsePosition pos = new ParsePosition(0);

formatter.parse(inputData, pos);

return inputData.length() == pos.getIndex();

 

Alternative 4 : use the java.util.Scanner object. Very useful if you have to scan multiple entries.

 

Scanner sc = new Scanner(inputData);

return sc.hasNextInt();

Scanner also has similar methods for longs, shorts, bytes, doubles, floats, BigIntegers, and BigDecimals as well as methods for integral types where you may input a base/radix other than 10 (10 is the default, which can be changed using the useRadix method).

 

=={{header|JavaScript}}==

// value is a number

}

//Or, in web browser in address field:

 

=={{header|LabVIEW}}==

{{VI solution|LabVIEW_Determine_if_a_string_is_numeric.png}}

=={{header|Lasso}}==

 

=={{header|Liberty BASIC}}==

DATA "PI", "0123", "-0123", "12.30", "-12.30", "123!", "0"

DATA "0.0", ".123", "-.123", "12E3", "12E-3", "12+3", "end"

[NotNumber]

end function

 

=={{header|Lisaac}}==

"123457".is_integer.println;

// write TRUE on stdin

 

=={{header|Logo}}==

 

=={{header|Lua}}==

This will also accept strings like "0xFF" or "314.16e-2" as numbers.

--it's a number

end;

 

 

 

=={{header|MATLAB}}==

 

 

 

 

=={{header|MAXScript}}==

(

try

)

 

 

=={{header|Mirah}}==

import java.text.ParsePosition

import java.util.Scanner

puts 'abc is not numeric' unless is_numeric5?('abc')

puts '123- is not numeric' unless is_numeric5?('123-')

 

=={{header|mIRC Scripting Language}}==

{{works with|mIRC}}

if (%value isnum) {

echo -s %value is numeric.

 

=={{header|Modula-3}}==

 

IMPORT IO, Fmt, Text;

IO.Put("isNumeric(-3.1415926) = " & Fmt.Bool(isNumeric("-3.1415926")) & "\n");

IO.Put("isNumeric(Foo123) = " & Fmt.Bool(isNumeric("Foo123")) & "\n");

 

<pre>

isNumeric(152) = TRUE

USER>WRITE $SELECT($ISVALIDNUM("123e4"):"Valid",1:"Invalid"),!

Valid</pre>

 

=={{header|Nemerle}}==

using System.Console;

 

WriteLine($"$not is numeric: $(IsNumeric(not))");

}

 

=={{header|Objective-C}}==

The ''NSScanner'' class supports scanning of strings for various types. The ''scanFloat'' method will return YES if the string is numeric, even if the number is actually too long to be contained by the precision of a ''float''.

 

NSLog( @"\"-123.4e5\" is numeric" );

else

NSLog( @"\"Not a number\" is not numeric" );

// prints: "-123.4e5" is numeric

 

The following function can be used to check if a string is numeric "totally"; this is achieved by checking if the scanner reached the end of the string after the float is parsed.

 

{

NSScanner *sc = [NSScanner scannerWithString: s];

}

return NO;

 

If we want to scan ''by hand'', we could use a function like the following, that checks if a number is an integer positive or negative number; spaces can appear at the beginning, but not after the number, and

the '+' or '-' can appear only ''attached'' to the number ("+123" returns YES, but "+ 123" returns NO).

 

{

NSUInteger len = [s length];

}

return (i == len) && status;

 

Here we assumed that in the internal encoding of a string (that should be Unicode), 1 comes after 0, 2 after 1 and so on until 9. Another way could be to get the C String from the NSString object, and then the parsing would be the same of the one we could do in standard C, so this path is not given.

 

=={{header|OCaml}}==

This function is not particularly useful in a statically typed language. Instead, one would just attempt to convert the string

to the desired type and handle parsing failure appropriately.

The task doesn't define which strings are considered "numeric", so we do ints and floats, which should catch the most common cases:

 

try ignore (int_of_string s); true

with _ -> false

with _ -> false

 

 

=={{header|Octave}}==

The builtin function <tt>isnumeric</tt> return true (1) if the argument is a data of type ''number''; the provided function <tt>isnum</tt> works the same for numeric datatype, while if another type is passed as argument, it tries to convert it to a number; if the conversion fails, it means it is not a string representing a number.

 

if ( isnumeric(a) )

r = 1;

else

endif

endfunction

disp(isnum("foo123")) % 0

disp(isnum("123bar")) % 0

 

 

 

=={{header|Oz}}==

{String.isInt S} orelse {String.isFloat S}

 

=={{header|PARI/GP}}==

my(t=type(eval(s)));

t == "t_INT" || t == "T_REAL"

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

{{works with|Perl|5.8}}

 

{{works with|Perl|5.8}}

Assuming that you don't care about [[IEEE]] notations like "NaN" or "Infinity", you probably just want to use a [[Regular expression matching|regular expression]].

 

if (/^\d+\z/) { print "is a whole number\n" }

if (/^-?\d+\z/) { print "is an integer\n" }

if (/^-?(?:\d+(?:\.\d*)?&\.\d+)\z/) { print "is a decimal number\n" }

if (/^([+-]?)(?=\d&\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?\z/)

 

There are also some commonly used modules for the task. Scalar::Util (distributed with 5.8) provides access to Perl's internal function "looks_like_number" for determining whether a variable looks like a number. Data::Types exports functions that validate data types using both the above and other regular expressions. Thirdly, there is "Regexp::Common" which has regular expressions to match various types of numbers. Those three modules are available from the CPAN.

If you're on a [[POSIX]] system, Perl supports the "POSIX::strtod" function. Its semantics are somewhat cumbersome, so here's a "getnum" wrapper function for more convenient access. This function takes a string and returns the number it found, or "undef" for input that isn't a C float. The "is_numeric" function is a front end to "getnum" if you just want to say, ''Is this a float?''

 

use POSIX;

my $str = shift;

}

 

 

Or you could check out the String::Scanf module on the CPAN instead. The POSIX module (part of the standard Perl distribution) provides the "strtod" and "strtol" for converting strings to double and longs, respectively.

 

 

=={{header|PHP}}==

$string = '123';

}

 

=={{header|PicoLisp}}==

The '[http://software-lab.de/doc/refF.html#format format]' function can

be used for that. It returns NIL if the given string is not a legal number

-> 123

 

 

: (format "-123.45" 4)

 

=={{header|Pike}}==

the sscanf format %f will find any kind of number.

the %s before and after make sure the number is not surrounded by other text.

 

int(0..1) is_number(string s)

{

is_number(num);

-> true

 

=={{header|PL/I}}==

is_numeric: procedure (text) returns (bit (1));

declare text character (*);

done:

return ('0'b);

<pre>

5 '1'B

 

=={{header|PL/SQL}}==

RETURN BOOLEAN

IS

WHEN others THEN

return( FALSE );

 

IF( IsNumeric( Value ) )

THEN

NULL;

 

=={{header|PowerShell}}==

Note: PowerShell 1.0 does not support 'try'

THis simply tries arithmetic with the argument and if that fails, ''false'' is returned.

try {

0 + $x | Out-Null

return $false

}

 

But this one doesn't work for strings like "8." though a . is appended it returns true!

Alternatively, you can use the static System.Int32.TryParse() method in the .NET framework.

 

$x2 = 0

$isNum = [System.Int32]::TryParse($x, [ref]$x2)

return $isNum

 

=={{header|PureBasic}}==

This routine parses the string to verify it's a number. It returns 1 if string is numeric, 0 if it is not. The character used as the decimal separator may be specified if desired.

#NotNumeric = #False

#IsNumeric = #True

Input()

CloseConsole()

<pre>'+3183.31151E+321' = 1

'-123456789' = 1

 

=={{header|Python}}==

 

Or for positive integers only:

 

 

Including complex, hex, binary, and octal numeric literals we get:

 

 

 

 

=={{header|R}}==

 

> suppressWarnings(!is.na(as.numeric(strings)))

[1] TRUE TRUE FALSE

 

=={{header|RapidQ}}==

$Typecheck on

 

showmessage (str$(isNumeric("-152.34","")))

end

 

=={{header|REBOL}}==

REBOL [

Title: "Is Numeric?"

URL: http://rosettacode.org/wiki/IsNumeric

]

} none

foreach x cases [print [x numeric? x pnumeric? x]]

 

=={{header|Retro}}==

 

 

=={{header|REXX}}==

 

 

 

 

 

 

 

=={{header|Ruby}}==

begin

Float(s)

true # numeric

end

 

or more compact:

 

!!Float(s) rescue false