Determine if a string is numeric: Difference between revisions

;Task:

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.

<br><br>

 

=={{header|8th}}==

=={{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)));

{{out}}

<pre>

 

=={{header|Aime}}==

is_numeric(text s)

{

 

return 0;

 

=={{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);

))

)

{{out}}

<pre>

 

=={{header|ALGOL W}}==

 

% determnines whether the string contains an integer, real or imaginary %

testIsNumeric( " -.345LI", true );

 

{{out}}

<pre>

=={{header|Apex}}==

The isNumeric() method is part of the Apex String Class. Note that it will return false if applied to a decimal, because the '.' character is not a Unicode digit.

String numericString = '123456';

String partlyNumericString = '123DMS';

System.debug(decimalString.isNumeric()); // this will be false

System.debug(decimalString.remove('.').isNumeric()); // this will be true

 

=={{header|APL}}==

{{works with|Dyalog APL}}

 

 

 

-- isNumString :: String -> Bool

on isNumString(s)

end script

end if

 

{{Out}}

 

=={{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:

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

{{out}}

<pre>

 

=={{header|BaCon}}==

 

PRINT "This is a number"

{{out}}

<pre>

Your string: 12.3

This is a number

Your string: 12E3

This is a number

Your string: PI

Not a number

Your string: Hello

Not a number

 

=={{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|Batch File}}==

if %a% == 0 (

if not "%arg%"=="0" (

) else (

echo Numeric.

 

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

{{works with|BBC BASIC for Windows}}

READ N$

IF FN_isanumber(N$) THEN

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

= FALSE

{{out}}

<pre>'PI' is NOT 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|Burlesque}}==

ps^^-]to{"Int""Double"}\/~[\/L[1==?*

 

 

=={{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 stringstream:

 

using namespace std;

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

}

 

Using find:

bool isNumeric( const char* pszInput, int nNumberBase )

{

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

}

 

Using all_of (requires C++11)

bool isNumeric(const std::string& input) {

return std::all_of(input.begin(), input.end(), ::isdigit);

}

 

 

=={{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|COBOL}}==

COBOL has the intrinsic functions <code>TEST-NUMVAL</code> and <code>TEST-NUMVAL-C</code> to check if a string is numeric (<code>TEST-NUMVAL-C</code> is used to check if it is also a monetary string). Implementations supporting the 20XX draft standard can also use <code>TEST-NUMVAL-F</code> for floating-point numbers. They return 0 if the string is valid, or the position of the first incorrect character.

 

procedure division.

display function test-numval-f("abc") end-display

display "failed numval-f test" end-display

end-if

 

===Implementation===

{{works with|OpenCOBOL}}

PROGRAM-ID. Is-Numeric.

 

 

GOBACK

 

=={{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.

===Alternative solution===

 

=={{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}}==

Using the standard Phobos function (currently binary and hex literals are not recognized):

 

 

void main() {

"-0b10101", "0x10.5"])

writefln(`isNumeric("%s"): %s`, s, s.strip().isNumeric(true));

{{out}}

<pre>isNumeric("12"): true

 

===An Implementation===

 

bool isNumeric(in string s) pure {

"-0b10101", "0x10.5"])

writefln(`isNumeric("%s"): %s`, s, s.isNumeric);

{{out}}

<pre>isNumeric("12"): true

isNumeric("-0b10101"): false

isNumeric("0x10.5"): false</pre>

 

=={{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.

 

 

{{out}} Example summarised:

</pre>

 

 

try {

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

return false

}

 

=={{header|EchoLisp}}==

The conversion function '''string->number''' returns #f - false - in the string is not a number, else returns a number, which is #t - true - as far as logical operations are concerned

(string->number "albert")

→ #f

(if (string->number 666) 'YES 'NO)

→ YES

 

=={{header|Elixir}}==

def is_numeric(str) do

case Float.parse(str) do

end

 

 

{{out}}

<pre>

["123", "-12.3", "-12e5", "+123"]

</pre>

 

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

{

}

}

 

{{out}}

</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|FreeBASIC}}==

I've therefore written a custom function which recognizes signed numbers in bases from 2 to 16 (but only integral numbers for bases other than 10). For base 10, it will treat "123." or ".123" as numbers but not ".". It doesn't recognize scientific notation but does recognize the integral prefixes &H, &O and &B if bases 16, 8 or 2 respectively are specified.

 

 

Dim Shared symbols(0 To 15) As UByte

Print

Print "Press any key to quit"

 

{{out}}

123xyz (base 10) => false

xyz (base 10) => false

</pre>

 

=={{header|Gambas}}==

Dim sAnswer, sString As String

 

Print sAnswer

 

Output:

<pre>

 

=={{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 ')

 

{{out}}

 

=={{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|Haxe}}==

static function isNumeric(n:String):Bool

{

}

}

 

=={{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

 

number(n)

print(n, " is not numeric!")

return

numeric("3/4")

numeric("abcdefg")

 

=={{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}}==

A far better validator can be found on StackOverflow[http://stackoverflow.com/questions/18082/validate-numbers-in-javascript-isnumeric]

return !isNaN(parseFloat(n)) && isFinite(n);

}

//Or, in web browser in address field:

// javascript:function isNumeric(n) {return !isNaN(parseFloat(n)) && isFinite(n);}; value="123.45e4"; if(isNumeric(value)) {alert('numeric')} else {alert('non-numeric')}

=={{header|jq}}==

The above expression will emit the corresponding number, or false if there is none. Here then is a boolean filter which will also emit true for each input that is a number:

 

=={{header|Julia}}==

 

 

for t in tests

 

{{out}}

<pre>

</pre>

 

=={{header|Kotlin}}==

 

fun isNumeric(input: String): Boolean =

val inputs = arrayOf("152", "-3.1415926", "Foo123", "-0", "456bar", "1.0E10")

for (input in inputs) println("$input is ${if (isNumeric(input)) "numeric" else "not numeric"}")

 

{{out}}

=={{header|LabVIEW}}==

{{VI solution|LabVIEW_Determine_if_a_string_is_numeric.png}}

=={{header|Lasso}}==

 

{{works with|Lasso|8 & 9 }}

 

 

{{works with|Lasso|9}}

 

 

=={{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|Maple}}==

try

if type(parse(s), numeric) then

printf("The string is not numeric."):

end try:

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}}==

 

% tests

disp(isnum("3.1415")) % 1

 

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

(

try

)

 

 

=={{header|MIPS Assembly}}==

# $a0 char val

# $a1 address pointer

li $a2,1

j loop

 

=={{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");

 

{{out}}

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

Valid</pre>

 

=={{header|Nemerle}}==

using System.Console;

 

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

}

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

]

return testData

{{out}}

<pre>

 

=={{header|Nim}}==

 

 

=={{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|PeopleCode}}==

Built-In Function

Syntax

/* do non-numeric processing */

End-if;

 

=={{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|Phix}}==

{{out}}

<pre>

</pre>

 

=={{header|PHP}}==

$string = '123';

if(is_numeric(trim($string))) {

}

 

=={{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|Prolog}}==

The code:

 

atom_string(Atom, String),

 

A predicate to test the code:

 

forall( member(String, Strings),

( ( numeric_string(String)

format('~w is ~w number.~n', [String, Result])

)

 

Example of using the test predicate:

 

123 is a number.

0.123 is a number.

NotNum is not a number.

1. is not a number.

 

=={{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()

{{out}}

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

=={{header|Python}}==

===Python: Simple int/float===

try:

float(s)

return False

 

 

Or for positive integers only:

 

 

===Python: Most numeric literals===

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

"""Return whether a literal can be parsed as a numeric value"""

castings = [int, float, complex,

except ValueError:

pass

 

Sample use, including value parsed, its type, and standard method str.isnumeric():

"""Return value of numeric literal or None if can't parse a value"""

castings = [int, float, complex,

for s in tests:

print("%14s -> %-14s %-20s is_numeric: %-5s str.isnumeric: %s" % (

{{out}}

<pre>

"inf" -> inf <class 'float'> is_numeric: True str.isnumeric: False

"-Infinity" -> -inf <class 'float'> is_numeric: True str.isnumeric: False</pre>

 

=={{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|Ring}}==

see isdigit("0123456789") + nl + # print 1

isdigit("0123a") # print 0

 

=={{header|Ruby}}==

begin

Float(s)

true # numeric

end

 

or more compact:

 

!!Float(s) rescue false

'''sample'''

strings.each do |str|

puts "%9p => %s" % [str, is_numeric?(str)]

{{out}}

<pre>

 

=={{header|Run BASIC}}==

print isNumeric("1ab")

 

[nxtDigit]

next i

1ab 0</pre>

 

=={{header|Rust}}==

fn parsable<T: FromStr>(s: &str) -> bool {

s.parse::<T>().is_ok()

 

=={{header|Scala}}==

def isNumeric(input: String): Boolean = input.forall(_.isDigit)

 

Or a more complete version, using a complex regular expression:

def isNumeric2(str: String): Boolean = {

str.matches(s"""[+-]?((\d+(e\d+)?[lL]?)|(((\d+(\.\d*)?)|(\.\d+))(e\d+)?[fF]?))""")

}

 

Or using the built-in number parsing and catching exceptions:

def isNumeric(str: String): Boolean = {

!throwsNumberFormatException(str.toLong) || !throwsNumberFormatException(str.toDouble)

try { f; false } catch { case e: NumberFormatException => true }

}

 

=={{header|Scheme}}==

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

 

=={{header|Seed7}}==

GetNumber reads a numeric literal from a string. The numeric literal is removed from the input string.

 

include "scanstri.s7i";

 

numberStri := getNumber(stri);

isNumeric := stri = "";

 

=={{header|Sidef}}==

There is the the ''String.looks_like_number'' method, which returns true when a given strings looks like a number:

 

Alternatively, we can use regular expressions to determine this:

 

(s ~~ /^[+-]?+(?=\.?[0-9])[0-9_]*+(?:\.[0-9_]++)?(?:[Ee](?:[+-]?+[0-9_]+))?\z/) ||

(s ~~ /^0(?:b[10_]*|x[0-9A-Fa-f_]*|[0-9_]+\b)\z/)

 

Sample:

for str in strings {

say ("%9s => %s" % (str, is_numeric(str)))

{{out}}

<pre>

0.1E-5 => true

50e => false

</pre>

 

The String class has the method <code>isNumeric</code>; this method (at least on version 3.0.4) does not recognize as number strings like '-123'! So I've written an extension...

 

realIsNumeric [

(self first = $+) |

'-3.78.23'. "false"

'123e3' "false: the notation is not recognized"

 

{{works with|Smalltalk/X}}

{{works with|GNU Smalltalk}}

(should work with all)

to handle radix numbers (such as 2r10111), use:

 

=={{header|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.

 

nchk convert(str,'real') :s(return)f(freturn)

nchk_end

output = isnum('abc')

output = isnum('A440')

 

{{out}}

=={{header|SQL}}==

{{works with|MS SQL|Server 2005}}

set @s = '1234.56'

 

 

if isnumeric(@s)=1 begin print 'Numeric' end

 

 

fun isInteger s = case Int.scan StringCvt.DEC Substring.getc (Substring.full s) of

SOME (_,subs) => Substring.isEmpty subs

| NONE => false

 

 

=={{header|Swift}}==

{{works with|Swift|2.x+}}

return Double(a) != nil

 

{{works with|Swift|1.x}}

This one only checks whether it is an integer:

return a.toInt() != nil

 

=={{header|Tcl}}==

 

 

=={{header|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.

 

>number nip ] is isNumeric

 

" a" isNumeric . ( fails, 'a' is not a valid integer in the decimal base )

" $a" isNumeric . ( succeeds, because $ is a valid override prefix )

 

=={{header|UNIX Shell}}==

#!/bin/bash

isnum() {

check 33.aa

check 3.3.3

 

{{out}}

 

=={{header|Ursa}}==

try

double str

return false

end try

 

=={{header|VBScript}}==

 

Returns a True if numeric and a false if not.

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.

if (Num_Eval(SUPPRESS)==0 && Cur_Char != '0') {

Return(FALSE)

} else {

Return(TRUE)

 

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|2005}}

 

If IsNumeric(Value) Then

PRINT "It is numeric."

 

=={{header|XLISP}}==

The inbuilt function <tt>STRING->NUMBER</tt> returns the numeric value of a string if it can. We discard this value and return the Boolean value 'true'; otherwise, the <tt>IF</tt> conditional will not be satisfied and will return 'false'.