Determine if a string is numeric

From Rosetta Code

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.

Contents 1 ActionScript 2 Ada 3 ALGOL 68 4 APL 5 AutoHotkey 6 AWK 7 C 8 C++ 9 C# 10 Clojure 11 ColdFusion 12 Common Lisp 13 D 14 E 15 Erlang 16 Factor 17 Forth 18 Fortran 19 Go 20 Groovy 21 Haskell 22 HicEst 23 IDL 24 Icon and Unicon 24.1 Icon 24.2 Unicon 25 J 26 Java 27 JavaScript 28 Lisaac 29 Logo 30 Lua 31 Mathematica 32 MATLAB 33 MAXScript 34 mIRC Scripting Language 35 Modula-3 36 MUMPS 37 Objective-C 38 OCaml 39 Octave 40 Oz 41 Pascal 42 Perl 43 PHP 44 PicoLisp 45 PL/I 46 PL/SQL 47 PowerShell 48 PureBasic 49 Python 50 R 51 REBOL 52 Ruby 53 Scala 54 Scheme 55 Smalltalk 56 SNOBOL4 57 SQL 58 Standard ML 59 Tcl 60 Toka 61 VBScript 62 Visual Basic .NET 63 Vedit macro language

[edit] ActionScript

public function isNumeric(num:String):Boolean
{
    return !isNaN(parseInt(num));
}

[edit] Ada

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

package Numeric_Tests is
   function Is_Numeric(Item : in String) return Boolean;
end Numeric_Tests;

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

package body Numeric_Tests is
 
   ----------------
   -- Is_Numeric --
   ----------------
 
   function Is_Numeric (Item : in String) return Boolean is
      Result : Boolean := True;
   begin
      declare
         Int : Integer;
      begin
         Int := Integer'Value(Item);
      exception
         when others =>
            Result := False;
      end;
      if Result = False then
         declare
            Real : Float;
         begin
            Real := Float'Value(Item);
            Result := True;
         exception
            when others =>
               null;
         end;
      end if;
      return Result;
   end Is_Numeric;
 
end Numeric_Tests;

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

with Ada.Text_Io; use Ada.Text_Io;
with Numeric_Tests; use Numeric_Tests; 
 
procedure Isnumeric_Test is
   S1 : String := "152";
   S2 : String := "-3.1415926";
   S3 : String := "Foo123";
begin
   Put_Line(S1 & " results in " & Boolean'Image(Is_Numeric(S1)));
   Put_Line(S2 & " results in " & Boolean'Image(Is_Numeric(S2)));
   Put_Line(S3 & " results in " & Boolean'Image(Is_Numeric(S3)));
end Isnumeric_Test;

The output of the program above is:

152 results in TRUE
-3.1415926 results in TRUE
Foo123 results in FALSE

[edit] ALGOL 68

Translation of: Ada

Works with: ALGOL 68 version Revision 1 - no extensions to language used

Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny

PROC is numeric = (REF STRING string) BOOL: (
  BOOL out := TRUE;
  PROC call back false = (REF FILE f)BOOL: (out:= FALSE; TRUE);
 
  FILE memory;
  associate(memory, string);
  on value error(memory, call back false);
  on logical file end(memory, call back false);
 
  UNION (INT, REAL, COMPL) numeric:=0.0;
  # use a FORMAT pattern instead of a regular expression #
  getf(memory, ($gl$, numeric));
  out
);
 
test:(
   STRING
     s1 := "152",
     s2 := "-3.1415926",
     s3 := "Foo123";
   print((
     s1, " results in ", is numeric(s1), new line,
     s2, " results in ", is numeric(s2), new line,
     s3, " results in ", is numeric(s3), new line
   ))
)
 

Output:

152 results in T
-3.1415926 results in T
Foo123 results in F

[edit] APL

Works with: Dyalog APL

      ⊃⎕VFI{w←⍵⋄((w='-')/w)←'¯'⋄w}'152 -3.1415926 Foo123'
1 1 0

[edit] 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.

list = 0 .14 -5.2 ten 0xf
Loop, Parse, list, %A_Space%
  MsgBox,% IsNumeric(A_LoopField)
Return
 
IsNumeric(x) {
  If x is number
    Return, 1
  Else Return, 0
}
 
;Output: 1  1  1  0  1

[edit] 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:

$ awk 'func isnum(x){return(x==x+0)}BEGIN{print isnum("hello"),isnum("-42")}'
0 1

[edit] C

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

#include <stdlib.h>
int isNumeric (const char * s)
{
    if (s == NULL || *s == '\0')
      return 0;
    char * p;
    strtod (s, &p);
    return *p == '\0';
}

[edit] C++

#include <sstream> // for istringstream
 
using namespace std;
 
bool isNumeric( const char* pszInput, int nNumberBase )
{
	istringstream iss( pszInput );
 
	if ( nNumberBase == 10 )
	{
		double dTestSink;
		iss >> dTestSink;
	}
	else if ( nNumberBase == 8 || nNumberBase == 16 )
	{
		int nTestSink;
		iss >> ( ( nNumberBase == 8 ) ? oct : hex ) >> nTestSink;
	}
	else
		return false;
 
	// was any input successfully consumed/converted?
	if ( ! iss )
		return false;
 
	// was all the input successfully consumed/converted?
	return ( iss.rdbuf()->in_avail() == 0 );
}

[edit] C#

Framework: .NET 2.0+

public static bool IsNumeric(string s)
{
    double Result;
    return double.TryParse(s, out Result);  // TryParse routines were added in Framework version 2.0.
}        
 
string value = "123";
if (IsNumeric(value)) 
{
  // do something
}

Framework: .NET 1.0+

public static bool IsNumeric(string s)
{
  try
  {
    Double.Parse(s);
    return true;
  }
  catch
  {
    return false;
  }
}

[edit] Clojure

(defn numeric? [s]
  (if-let [s (seq s)]
    (let [s (if (= (first s) \-) (next s) s)
          s (drop-while #(Character/isDigit %) s)
          s (if (= (first s) \.) (next s) s)
          s (drop-while #(Character/isDigit %) s)]
      (empty? s))))

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

(numeric? [\1 \2 \3])  ;; yields logical true

[edit] ColdFusion

Adobe's ColdFusion

<cfset TestValue=34>
  TestValue: <cfoutput>#TestValue#</cfoutput><br>
<cfif isNumeric(TestValue)>
  is Numeric.
<cfelse>
  is NOT Numeric.
</cfif>
 
<cfset TestValue="NAS">
  TestValue: <cfoutput>#TestValue#</cfoutput><br>
<cfif isNumeric(TestValue)>
  is Numeric.
<cfelse>
  is NOT Numeric.
</cfif>

[edit] Common Lisp

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

(defun numeric-string-p (string)
  (numberp (read-from-string string)))

However, read[-from-string] parses more than just numbers, and some input can have side effects and/or large memory allocation. The parse-number library provides a numbers-only equivalent of read.

(defun numeric-string-p (string)
  (handler-case (progn (parse-number:parse-number string)
                       t)  ; parse succeeded, discard it and return true (t)
    (parse-number::invalid-number ()
      nil)))  ; parse failed, return false (nil)

[edit] D

import std.stdio, std.string, std.conv, std.regexp;
 
bool isNumeric(string s) {
    try
        toDouble(s.strip());
    catch (Error e)
        return false;
    return true;
}
 
bool isInt(string s) {
    foreach (i, c; s) {
        if (i == 0 && (c == '-' || c == '+'))
            continue;
        if (c >= '0' && c <= '9')
            continue;
        return
            false;
    }
    return true;
}
 
bool isInt2(string s) {
    return cast(bool)search(s, r"^[-+]?\d+$");
}
 
bool isInt3(string s) {
    try
        toInt(s.strip());
    catch (Error e)
        return false;
    return true;
}
 
void main() {
    foreach (s; ["12", " 12\t", "hello12", "-12", "0-12", "+12", "0x10", "6b"]) {
        writefln("isNumeric(", s, ") = ", isNumeric(s));
        writefln("isInt(", s, ") = ", isInt(s));
        writefln("isInt2(", s, ") = ", isInt2(s));
        writefln("isInt3(", s, ") = ", isInt3(s));
        writefln();
    }
}

[edit] E

def isNumeric(specimen :String) {
    try {
        <import:java.lang.makeDouble>.valueOf(specimen)
        return true
    } catch _ {
       return false
    }
}

[edit] 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 is_number/1, 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 is_number/1.

is_numeric(L) ->
    Float = (catch erlang:list_to_float(L)),
    Int = (catch erlang:list_to_integer(L)),
    is_number(Float) orelse is_number(Int).

[edit] Factor

: numeric? ( string -- ? ) string>number >boolean ;

[edit] Forth

Works with: gforth version 0.6.2

: is-numeric ( addr len -- )
  2dup snumber? ?dup if      \ not standard, but >number is more cumbersome to use
   0< if
     -rot type ."  as integer = " .
   else
     2swap type ."  as double = " <# #s #> type
   then
  else 2dup >float if
    type ."  as float = " f.
  else
    type ."  isn't numeric in base " base @ dec.
  then then ;
 
s" 1234" is-numeric    \ 1234 as integer = 1234
s" 1234." is-numeric    \ 1234. as double = 1234
s" 1234e" is-numeric    \ 1234e as float = 1234.
s" $1234" is-numeric    \ $1234 as integer = 4660  ( hex literal )
s" %1010" is-numeric    \ %1010 as integer = 10  ( binary literal )
s" beef" is-numeric    \ beef isn't numeric in base 10
hex
s" beef" is-numeric    \ beef as integer = BEEF
s" &1234" is-numeric    \ &1234 as integer = 4D2 ( decimal literal )

[edit] Fortran

FUNCTION is_numeric(string)
  IMPLICIT NONE
  CHARACTER(len=*), INTENT(IN) :: string
  LOGICAL :: is_numeric
  REAL :: x
  INTEGER :: e
  READ(string,*,IOSTAT=e) x
  is_numeric = e == 0
END FUNCTION is_numeric

[edit] Go

 
import "strconv"
 
func IsNumeric(s string) bool {
    _, err := strconv.Atof(s)
    return err == nil
}
 

[edit] 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 isNumeric = {
    def formatter = java.text.NumberFormat.instance
    def pos = [0] as java.text.ParsePosition
    formatter.parse(it, pos)
 
    // if parse position index has moved to end of string
    // them the whole string was numeric
    pos.index == it.size()
}

Test Program:

println isNumeric('1')
println isNumeric('-.555')
println isNumeric('1,000,000')
println isNumeric(' 1 1 1 1 ')
println isNumeric('abcdef')

Output:

true
true
true
false
false

[edit] 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):

isInteger s = case reads s :: [(Integer, String)] of
  [(_, "")] -> True
  _         -> False
 
isDouble s = case reads s :: [(Double, String)] of
  [(_, "")] -> True
  _         -> False
 
isNumeric :: String -> Bool
isNumeric s = isInteger s || isDouble s

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:

areDigits = all isDigit
isDigit  selects ASCII digits i.e. '0'..'9'
isOctDigit selects '0'..'7'
isHexDigit selects '0'..'9','A'..'F','a'..'f'

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

[edit] HicEst

                              !    = bin + 2*int + 4*flt + 8*oct +16*hex + 32*sci
   isNumeric("1001")          ! 27 =  1       1       0       1       1        0
   isNumeric("123")           ! 26 =  0       1       0       1       1        0
   isNumeric("1E78")          ! 48 =  0       0       0       0       1        1
   isNumeric("-0.123")        !  4 =  0       0       1       0       0        1
   isNumeric("-123.456e-78")  ! 32 =  0       0       0       0       0        1
   isNumeric(" 123")          !  0: leading blank
   isNumeric("-123.456f-78")  !  0: illegal character f
 
 
FUNCTION isNumeric(string)    ! true ( > 0 ), no leading/trailing blanks
   CHARACTER string
   b = INDEX(string, "[01]+", 128, Lbin)                ! Lbin returns length found
   i = INDEX(string, "-?\d+", 128, Lint)                ! regular expression: 128
   f = INDEX(string, "-?\d+\.\d*", 128, Lflt)
   o = INDEX(string, "[0-7]+",    128, Loct)
   h = INDEX(string, "[0-9A-F]+", 128, Lhex)            ! case sensitive: 1+128
   s = INDEX(string, "-?\d+\.*\d*E[+-]*\d*", 128, Lsci)
   IF(anywhere) THEN     ! 0 (false) by default
     isNumeric = ( b > 0 ) + 2*( i > 0 ) + 4*( f > 0 ) + 8*( o > 0 ) + 16*( h > 0 ) + 32*( s > 0 )
   ELSEIF(boolean) THEN  ! 0 (false) by default
     isNumeric = ( b + i + f + o + h + s ) > 0 ! this would return 0 or 1
   ELSE
     L = LEN(string)
     isNumeric = (Lbin==L) + 2*(Lint==L) + 4*(Lflt==L) + 8*(Loct==L) + 16*(Lhex==L) + 32*(Lsci==L)
   ENDIF
 END

[edit] IDL

function isnumeric,input
  on_ioerror, false
  test = double(input)
  return, 1
  false: return, 0
end

Could be called like this:

if isnumeric('-123.45e-2') then print, 'yes' else print, 'no'
; ==> yes
if isnumeric('picklejuice') then print, 'yes' else print, 'no'
; ==> no

[edit] Icon and Unicon

[edit] Icon

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")
 

[edit] Unicon

This Icon solution works in Unicon.

[edit] J

isNumeric=: _ ~: _".]
isNumericScalar=: [: (*./ *. 0=#@$) isNumeric
TXT=: ' is not a number.';' represents a scalar numeric value.'
sayIsNumericScalar=: , ;@(TXT{~isNumericScalar)

Examples of use:

   isNumeric '152'
1
   isNumeric '152 -3.1415926 Foo123'
1 1 0
   isNumericScalar '152 -3.1415926 Foo123'
0
   sayIsNumericScalar '-3.1415926'
-3.1415926 represents a scalar numeric value.

[edit] 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.

public boolean isNumeric(String input) {
  try {
    Integer.parseInt(input);
    return true;
  }
  catch (NumberFormatException e) {
    // s is not numeric
    return false;
  }
}

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

private static final boolean isNumeric(final String s) {
  if (s == null || s.isEmpty()) return false;
  for (int x = 0; x < s.length(); x++) {
    final char c = s.charAt(x);
    if (x == 0 && (c == '-')) continue;  // negative
    if ((c >= '0') && (c <= '9')) continue;  // 0 - 9
    return false; // invalid
  }
  return true; // valid
}

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

public static boolean isNumeric(String inputData) {
  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.

public static boolean isNumeric(String inputData) {
  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.

public static boolean isNumeric(String inputData) {
  Scanner sc = new Scanner(inputData);
  return sc.hasNextInt();
}

[edit] JavaScript

string value = "123.45e7";
if (isFinite(value)) 
{
  // do something
}
//Or, in web browser in URL box:
//  javascript:value="123.45e4"; if(isFinite(value)) {alert('numeric')} else {alert('non-numeric')}

[edit] Lisaac

- is_numeric s : ABSTRACT_STRING : BOOLEAN <- (
  + result : BOOLEAN
  + p : NATIVE_ARRAY[CHARACTER];
  ((s != NULL) && {s.count > 0}).if {
    p := s.to_external;
    `strtod(@p, &@p)`;
    result := p.item(0) == '\0'
  };
  result
);

[edit] Logo

show number? "-1.23    ; true

[edit] Lua

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

function isNumeric(a)
    return type(tonumber(a)) == "number"
end

[edit] Mathematica

Use built-in numeric test

DigitQ["02553352000242"]

[edit] MATLAB

This can be done using several methods in MATLAB. One of the possible ways is given below. An important note, the strings 'i' and 'j' will be recognized as imaginary numbers, not as strings containing the letters 'i' and 'j.' Also, the output of this procedure will be a boolean 0 if the string is a number, or a boolean 1 if it is not.

isempty(str2num('32.10'))
 
ans =
 
     0 %Is a numeric string
 
>> isempty(str2num('jh'))
 
ans =
 
     1 %Is a character string
 
>> isempty(str2num('32i'))
 
ans =
 
     0 %Is a numeric string

[edit] MAXScript

fn isNumeric str =
(
    try
    (
        (str as integer) != undefined
    )
    catch(false)
)
 
isNumeric "123"

[edit] mIRC Scripting Language

Works with: mIRC

var %value = 3
if ($1 isnum) {
  echo -s $1 is numeric.
}

[edit] Modula-3

MODULE Numeric EXPORTS Main;
 
IMPORT IO, Fmt, Text;
 
PROCEDURE isNumeric(s: TEXT): BOOLEAN =
  BEGIN
    FOR i := 0 TO Text.Length(s) DO
      WITH char = Text.GetChar(s, i) DO
        IF i = 0 AND char = '-' THEN
          EXIT;
        END;
        IF char >= '0' AND char <= '9' THEN
          EXIT;
        END;
        RETURN FALSE;
      END;
    END;
    RETURN TRUE;
  END isNumeric;      
 
BEGIN
  IO.Put("isNumeric(152) = " & Fmt.Bool(isNumeric("152")) & "\n");
  IO.Put("isNumeric(-3.1415926) = " & Fmt.Bool(isNumeric("-3.1415926")) & "\n");
  IO.Put("isNumeric(Foo123) = " & Fmt.Bool(isNumeric("Foo123")) & "\n");
END Numeric.

Output:

isNumeric(152) = TRUE
isNumeric(-3.1415926) = TRUE
isNumeric(Foo123) = FALSE

[edit] MUMPS

In MUMPS, strings are automatically converted to numbers when a unary or binary arithmetic operator works upon them. If there are no leading digits, a string converts to zero. If there a string of digits followed by an "e" or an "E" followed in turn by more digits, the numbers after the letter are treated as an exponent.

Examples from command line:

USER>WRITE +"1"
1
USER>WRITE +"1A"
1
USER>WRITE +"A1"
0
USER>WRITE +"1E"
1
USER>WRITE +"1E2"
100
USER>WRITE +"1EA24"
1
USER>WRITE +"1E3A"
1000
USER>WRITE +"1E-3"
.001

There is a function, $ISVALIDNUM, to do the testing.

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

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

[edit] Objective-C

Works with: GCC Works with: OpenStep Works with: GNUstep

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.

if( [[NSScanner scannerWithString:@"-123.4e5"] scanFloat:NULL] )
	NSLog( @"\"-123.4e5\" is numeric" );
else
	NSLog( @"\"-123.4e5\" is not numeric" );
if( [[NSScanner scannerWithString:@"Not a number"] scanFloat:NULL] )
	NSLog( @"\"Not a number\" is numeric" );
else
	NSLog( @"\"Not a number\" is not numeric" );
// prints: "-123.4e5" is numeric
// prints: "Not a number" is not 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.

BOOL isNumeric(NSString *s)
{
   NSScanner *sc = [NSScanner scannerWithString: s];
   if ( [sc scanFloat:NULL] )
   {
      return [sc isAtEnd];
   }
   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).

BOOL isNumericI(NSString *s)
{
   NSUInteger len = [s length];
   NSUInteger i;
   BOOL status = NO;
 
   for(i=0; i < len; i++)
   {
       unichar singlechar = [s characterAtIndex: i];
       if ( (singlechar == ' ') && (!status) )
       {
         continue;
       }
       if ( ( singlechar == '+' ||
              singlechar == '-' ) && (!status) ) { status=YES; continue; }
       if ( ( singlechar >= '0' ) &&
            ( singlechar <= '9' ) )
       {
          status = YES;
       } else {
          return NO;
       }
   }
   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.

[edit] 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:

let is_int s =
  try ignore (int_of_string s); true
  with _ -> false
 
let is_float s =
  try ignore (float_of_string s); true
  with _ -> false
 
let is_numeric s = is_int s || is_float s

[edit] Octave

The builtin function isnumeric return true (1) if the argument is a data of type number; the provided function isnum 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.

function r = isnum(a)
  if ( isnumeric(a) )
    r = 1;
  else
    o = str2num(a);
    r = !isempty(o);
  endif
endfunction
 
% tests
disp(isnum(123))      % 1
disp(isnum("123"))    % 1
disp(isnum("foo123")) % 0
disp(isnum("123bar")) % 0
disp(isnum("3.1415")) % 1

[edit] Oz

fun {IsNumeric S}
   {String.isInt S} orelse {String.isFloat S}
end

[edit] Pascal

function IsNumeric(Value: string; const AllowFloat: Boolean): Boolean;
var
  ValueInt: Integer;
  ValueFloat: Extended;
  ErrCode: Integer;
begin
// Check for integer: Val only accepts integers when passed integer param
Value := SysUtils.Trim(Value);
Val(Value, ValueInt, ErrCode);
Result := ErrCode = 0;      // Val sets error code 0 if OK
if not Result and AllowFloat then
    begin
    // Check for float: Val accepts floats when passed float param
    Val(Value, ValueFloat, ErrCode);
    Result := ErrCode = 0;    // Val sets error code 0 if OK
    end;
end;

[edit] Perl

Works with: Perl version 5.8

use Scalar::Util qw(looks_like_number);
print looks_like_number($str) ? "numeric" : "not numeric\n";

Works with: Perl version 5.8 Quoting from perlfaq4:

How do I determine whether a scalar is a number/whole/integer/float?

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

if (/\D/)            { print "has nondigits\n" }
if (/^\d+$/)         { print "is a whole number\n" }
if (/^-?\d+$/)       { print "is an integer\n" }
if (/^[+-]?\d+$/)    { print "is a +/- integer\n" }
if (/^-?\d+\.?\d*$/) { print "is a real number\n" }
if (/^-?(?:\d+(?:\.\d*)?&\.\d+)$/) { print "is a decimal number\n" }
if (/^([+-]?)(?=\d&\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/)
                     { print "a C float\n" }

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?

sub getnum {
    use POSIX;
    my $str = shift;
    $str =~ s/^\s+//;
    $str =~ s/\s+$//;
    $! = 0;
    my($num, $unparsed) = strtod($str);
    if (($str eq '') && ($unparsed != 0) && $!) {
        return undef;
    } else {
        return $num;
    }
}
 
sub is_numeric { defined getnum($_[0]) }

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.

[edit] PHP

<?php
$string = '123';
if(is_numeric($string)) {
}

[edit] PicoLisp

The 'format' function can be used for that. It returns NIL if the given string is not a legal number

: (format "123")
-> 123
 
: (format "123a45")
-> NIL
 
: (format "-123.45" 4)
-> 1234500

[edit] PL/I

 
string = '1234ABc';
 
if verify (string, '0123456789') > 0 then
   put skip list ('string is not numeric');
 
 

[edit] PL/SQL

FUNCTION IsNumeric( VALUE IN VARCHAR2 )
RETURN BOOLEAN
IS
  help NUMBER;
BEGIN
  help := TO_NUMBER( VALUE );
  RETURN( TRUE );
EXCEPTION
  WHEN OTHERS THEN
    RETURN( FALSE );
END;

VALUE VARCHAR2( 10 ) := '123';
IF( IsNumeric( VALUE ) )
  THEN
    NULL;
END  IF;

[edit] PowerShell

Note: PowerShell 1.0 does not support 'try' THis simply tries arithmetic with the argument and if that fails, false is returned.

function isNumeric ($x) {
    try {
        0 + $x | Out-Null
        return $true
    } catch {
        return $false
    }
}

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

function isNumeric ($x) {
    $x2 = 0
    $isNum = [System.Int32]::TryParse($x, [ref]$x2)
    return $isNum
}

[edit] 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.

Procedure IsNumeric(InString.s, DecimalCharacter.c = '.')
  #NotNumeric = #False
  #IsNumeric = #True
 
  InString = Trim(InString)
  Protected IsDecimal, CaughtDecimal, CaughtE
  Protected IsSignPresent, IsSignAllowed = #True, CountNumeric
  Protected *CurrentChar.Character = @InString
 
  While *CurrentChar\c
    Select *CurrentChar\c
      Case '0' To '9'
        CountNumeric + 1
        IsSignAllowed = #False
      Case DecimalCharacter
        If CaughtDecimal Or CaughtE Or CountNumeric = 0
          ProcedureReturn #NotNumeric
        EndIf
 
        CountNumeric = 0
        CaughtDecimal = #True
        IsDecimal = #True
      Case  '-', '+'
        If IsSignPresent Or Not IsSignAllowed: ProcedureReturn #NotNumeric: EndIf 
        IsSignPresent = #True
      Case 'E', 'e'
        If CaughtE Or CountNumeric = 0
          ProcedureReturn #NotNumeric
        EndIf
 
        CaughtE = #True
        CountNumeric = 0
        CaughtDecimal = #False
        IsSignPresent = #False
        IsSignAllowed = #True
      Default
        ProcedureReturn #NotNumeric
    EndSelect
    *CurrentChar + SizeOf(Character)
  Wend
 
  If CountNumeric = 0: ProcedureReturn #NotNumeric: EndIf
  ProcedureReturn #IsNumeric
EndProcedure
 
If OpenConsole()
  PrintN("'+3183.31151E+321' = " + Str(IsNumeric("+3183.31151E+321")))
  PrintN("'-123456789' = " + Str(IsNumeric("-123456789")))
  PrintN("'123.45.6789+' = " + Str(IsNumeric("123.45.6789+")))
  PrintN("'-e' = " + Str(IsNumeric("-e")))
  Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
  Input()
  CloseConsole()
EndIf

Sample output:

'+3183.31151E+321' = 1
'-123456789' = 1
'123.45.6789+' = 0
'-e' = 0

[edit] Python

s = '123'
try:
  i = float(s)
except ValueError:
    # not numeric
else:
    # numeric

Or for positive integers only:

s = '123'
if s.isdigit():
    # numeric

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

def is_numeric(lit):
    'Return value of numeric literal string or ValueError exception'
 
    # Handle '0'
    if lit == '0': return 0
    # Hex/Binary
    litneg = lit[1:] if lit[0] == '-' else lit
    if litneg[0] == '0':
        if litneg[1] in 'xX':
            return int(lit,16)
        elif litneg[1] in 'bB':
            return int(lit,2)
        else:
            try:
                return int(lit,8)
            except ValueError:
                pass
 
    # Int/Float/Complex
    try:
        return int(lit)
    except ValueError:
        pass
    try:
        return float(lit)
    except ValueError:
        pass
    return complex(lit)

Sample use:

>>> for s in ['0', '00', '123', '-123.', '-123e-4', '0123', '0x1a1', '-123+4.5j', '0b0101', '0.123', '-0xabc', '-0b101']:
    print "%14s -> %-14s %s" % ('"'+s+'"', is_numeric(s), type(is_numeric(s)))
 
           "0" -> 0              <type 'int'>
          "00" -> 0              <type 'int'>
         "123" -> 123            <type 'int'>
       "-123." -> -123.0         <type 'float'>
     "-123e-4" -> -0.0123        <type 'float'>
        "0123" -> 83             <type 'int'>
       "0x1a1" -> 417            <type 'int'>
   "-123+4.5j" -> (-123+4.5j)    <type 'complex'>
      "0b0101" -> 5              <type 'int'>
       "0.123" -> 0.123          <type 'float'>
      "-0xabc" -> -2748          <type 'int'>
      "-0b101" -> -5             <type 'int'>
>>>

[edit] R

isnumeric <- function(s) !is.na(as.numeric(s))

[edit] REBOL

 
rebol [
	Title: "Is Numeric?"
	Author: oofoe
	Date: 2009-12-04
	URL: http://rosettacode.org/wiki/IsNumeric
]
 
; Built-in.
 
numeric?: func [x][not error? try [to-decimal x]]
 
; Parse dialect for numbers.
 
sign:   [0 1 "-"]
digit:  charset "0123456789"
int:    [some digit]
float:  [int "." int]
number: [
	sign float ["e" | "E"] sign int |
	sign int ["e" | "E"] sign int |
	sign float |
	sign int 
]
 
pnumeric?: func [x][parse x number]
 
; Test cases.
 
cases: parse {
   10 -99 
   10.43 -12.04 
   1e99 1.0e10 -10e3 -9.12e7 2e-4 -3.4E-5
   3phase  Garkenhammer  e  n3v3r  phase3
} none
foreach x cases [print [x  numeric? x  pnumeric? x]]
 

[edit] Ruby

def isNumeric(s)
  begin
    Float(s)
  rescue
    false # not numeric
  else
    true # numeric
  end
end

or more compact:

def isNumeric(s)
    Float(s) != nil rescue false
end

[edit] Scala

Translated from the Groovy and Java examples

import java.text.{NumberFormat, ParsePosition}
 
def isNumeric(input: String): Boolean = {
    val formatter = NumberFormat.getInstance
    val pos = new ParsePosition(0)
    formatter.parse(input, pos)
    input.length == pos.getIndex // valid if parse position is at end of string
}

[edit] Scheme

string->number returns #f when the string is not numeric and otherwise the number, which is non-#f and therefore true.

(define (numeric? s) (string->number s))

[edit] Smalltalk

Works with: GNU Smalltalk The String class has the method isNumeric; this method (at least on version 3.0.4) does not recognize as number strings like '-123'! So I've written an extension...

String extend [
  realIsNumeric [
     (self first = $+) |
     (self first = $-) 
        ifTrue: [
           ^ (self allButFirst) isNumeric
        ]
        ifFalse: [
           ^ self isNumeric
        ]
  ]
]
 
{ '1234'.            "true"
  '3.14'. '+3.8111'. "true"
  '+45'.             "true"
  '-3.78'.           "true"
  '-3.78.23'. "false"
  '123e3'     "false: the notation is not recognized"
} do: [ :a | a realIsNumeric printNl ]

[edit] SNOBOL4

This task is easy in Snobol. Use the convert( ) function as a predicate returning success (T) or failure (F) for string to real conversion.

        define('nchk(str)') :(nchk_end)
nchk    convert(str,'real') :s(return)f(freturn)
nchk_end        
 
*       # Wrapper for testing
        define('isnum(str)') :(isnum_end)
isnum   isnum = 'F'; isnum = nchk(str) 'T'
        isnum = isnum ': ' str :(return)
isnum_end        
 
*       # Test and display
        output = isnum('123')
        output = isnum('123.0')
        output = isnum('123.')
        output = isnum('-123')
        output = isnum('3.14159')
        output = isnum('1.2.3')
        output = isnum('abc')
        output = isnum('A440')
end

Output:

T: 123
T: 123.0
T: 123.
T: -123
T: 3.14159
F: 1.2.3
F: abc
F: A440

[edit] SQL

Works with: MS SQL version Server 2005

DECLARE @s VARCHAR(10)
SET @s = '1234.56'
 
print isnumeric(@s) --prints 1 if numeric, 0 if not.
 
IF isnumeric(@s)=1 BEGIN print 'Numeric' END 
ELSE print 'Non-numeric'

[edit] Standard ML

(* this function only recognizes integers in decimal format *)
fun isInteger s = case Int.scan StringCvt.DEC Substring.getc (Substring.full s) of
   SOME (_,subs) => Substring.isEmpty subs
 | NONE          => false
 
fun isReal s = case Real.scan Substring.getc (Substring.full s) of
   SOME (_,subs) => Substring.isEmpty subs
 | NONE          => false
 
fun isNumeric s = isInteger s orelse isReal s

[edit] Tcl

if {
    [string is double -strict $varname]
} then {  ... }

Also string is integer (, string is alnum etc etc)

[edit] Toka

Returns a flag of TRUE if character-string parameter represents a signed or unsigned integer. Otherwise returns a flag of FALSE. The success or failure is dependent on the source is valid in the current numeric base. The >number function also recognizes several optional prefixes for overriding the current base during conversion.

[ ( string -- flag )
  >number nip ] is isNumeric
 
( Some tests )
decimal
" 100" isNumeric .     ( succeeds, 100 is a valid decimal integer )
" 100.21" isNumeric .  ( fails, 100.21 is not an integer)
" a" isNumeric .       ( fails, 'a' is not a valid integer in the decimal base )
" $a" isNumeric .      ( succeeds, because $ is a valid override prefix )
                       ( denoting that the following character is a hexadecimal number )

[edit] VBScript

IsNumeric(Expr)

Returns a True if numeric and a false if not.

[edit] Visual Basic .NET

Works with: Visual Basic version 2005

Dim Value As String = "+123"
 
If IsNumeric(Value) Then
    PRINT "It is numeric."
End If

[edit] Vedit macro language

This routine returns TRUE if there is numeric value at current cursor location. Only signed and unsigned integers are recognized, in decimal, hex (preceded with 0x) or octal (preceded with 0o). Remove the SUPPRESS option to evaluate an expression instead of single numeric value.

:IS_NUMERIC:
if (Num_Eval(SUPPRESS)==0 && Cur_Char != '0') {
    Return(FALSE)
} else {
    Return(TRUE)
}