Determine if a string is numeric: Difference between revisions

</pre>

The code:

db $0E,$08,$0A,$00,$9E,$20,$28,$32,$30,$36,$34,$29,$00,$00,$00 ;required init code on commodore 64 floppy disks

*=$0810

db "1.000.000",0

TestString8:

 

{{out}}

 

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

 

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly Raspberry PI */

/* program strNumber.s */

.include "../includeARM64.inc"

 

 

=={{header|Action!}}==

The solution below uses conversion string to number and number to string to determine if the string is numeric.

{{libheader|Action! Tool Kit}}

 

BYTE FUNC AreEqual(CHAR ARRAY a,b)

Test("1.23BC")

Test("5.6.3")

 

=== Using a finite-state machine ===

The solution below uses a finite-state machine to determine if a string is numeric.

IF c='- OR c='+ THEN

RETURN (1)

Test("1.23BC")

Test("5.6.3")

 

{{out}}

 

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

 

1 1 0

⊃⎕VFI '-' ⎕R '¯' ⊣ '152 -3.1415926 Foo123' ⍝ Simple: (ditto)

 

{{works with|GNU APL}}

{∧/⍵∊(⊃,¨'0123456789¯.+')}¨'152' '¯3.1415926' 'Foo123'

1 1 0

 

=={{header|AppleScript}}==

-- isNumString :: String -> Bool

on isNumString(s)

end script

end if

 

{{Out}}

 

The classic way's slightly simpler, since the coercion result ''must'' be a real or an integer if the coercion itself didn't error.

 

if (s's class is not text) then return false

try

return false

end try

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

 

 

 

=={{header|Arturo}}==

print numeric? "1234"

print numeric? "1234 hello world"

print numeric? "12.34"

print numeric? "!#@$"

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

 

IF REGEX(s$, "^[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$") THEN

ELSE

PRINT "Not a number"

{{out}}

<pre>

 

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

#La función isNumeric() es nativa de BASIC256.

#Devuelve 1 (verdadero) si la expresión es un entero,

print s, " => "; isNumeric(s)

end

{{out}}

<pre>

 

==={{header|Commodore BASIC}}===

10 input "Enter a string";s$:gosub 1000:print

20 if r then print "You entered a number.":goto 99

1000 t1=val(s$):t1$=str$(t1)

1010 r=t1$=s$ or t1$=" "+s$

 

{{out}}

&#9608;</pre>

==={{header|QB64}}===

Input "Enter a text or a number: ", v$ 'The "$" establishes that this is a string variable. So whatever entered will be stored as

'a string.

Sleep

System

{{out}}

<pre>

 

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

 

=={{header|Befunge}}==

v _v# < < 0<

>~:0\`#v_>::"0"-0\`\"9"-0`+!#v_:"."-!#v_::"E"-\"e"-*!#v_ v

>~:0\`#v_>::"0"-0\`\"9"-0`+!#v_:"."-!#v_::"E"-\"e"-*!v 0 > v

^ $< v < << ^_^#-"-"<

 

 

'192.168.0.1' Not numeric

</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==?*

 

Assumes string is not empty.

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 sharp|C#}}==

'''Framework:''' [[.NET]] 2.0+

 

{

double Result;

{

// do something

 

'''Framework:''' [[.NET]] 1.0+

 

{

try

return false;

}

 

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

ColdFusion Script (CfScript)

 

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

 

Clojure has a fairly rich set of numeric literals, including Ratios, BigInts and BigDecimals. The Clojure reader will attempt to read any form starting with a digit (optionally preceded by a '+' or '-') as a number. So the following checks to see if such a read is successful:

(require '[clojure.edn :as edn])

(import [java.io PushbackReader StringReader])

; Check that the string has nothing after the number

(= -1 (.read reader)))))))

user=> (number-string? "2r101010")

true

user=> (number-string? "22/7")

true

 

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

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:

 

=={{header|Dyalect}}==

try {

parse(this) is Integer or Float

var str = "1234567"

 

=={{header|Déjà Vu}}==

true

try:

 

for v in [ "1" "0" "3.14" "hello" "12e3" "12ef" "-3" ]:

{{out}}

<pre>"-3" true

 

=={{header|E}}==

try {

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

return false

}

 

=={{header|EasyLang}}==

.

for s$ in [ "abc" "21a" "1234" "-13" "7.65" ]

 

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

 

=={{header|ERRE}}==

Short form using predeclared ERRE functions VAL and STR$.

PROGRAM NUMERIC

 

IF ANS% THEN PRINT("is num") ELSE PRINT("not num")

END PROGRAM

{{out}}

<pre>Enter a string? 12.30

 

=={{header|Euphoria}}==

 

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

For '2a5': false

For '-2.1e5': 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|Free Pascal}}==

var

potentialInteger: integer;

isNumeric := (integerError = 0) or (realError = 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}}==

This uses a library function to meet the task's requirements:

 

import (

fmt.Printf(" %4s -> %t\n", s, isNumeric(s))

}

 

{{out}}

 

This uses both a library function and a custom one but only checks for integerness:

 

import (

i := "one"

fmt.Printf(" %3s -> %t\n", i, isInt(i))

 

{{out}}

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

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

 

=={{header|i}}==

number(n)

errors {

numeric("abcdefg")

numeric("1234test")

 

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

The function <tt>isnumber</tt> tests for strings that parse directly to numbers. This test excludes symbols, such as &pi; and <tt>1 + 1</tt>, that evaluate to numbers as well as certain elaborate numbers (large integers, rationals and complex numbers) whose literals parse to expressions that must be evaluated to yield numbers.

 

 

isnumber(s::AbstractString) = tryparse(Float64, s) isa Number

fl = isnumber(t) ? "is" : "is not"

@printf("%35s %s a direct numeric literal.\n", t, fl)

 

{{out}}

 

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

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

We have to define our IsNumber()

Version 2 handle decimal point character. For code M2000 use dot, but for input and output use the user specified decimal point, from OS. Function Str$(1.2) return a string with a dot always, but if we place a second parameter this change. Print str$(1.2, "") maybe return 1,2 and nor 1.2. Print str$(1.2, "#.00") maybe return 1.20 or 1,20. The reverse function is Val() which can take more characters so A Val("121mm") is 121, and with a second parameter we can interpret properly the decimal dot: Print Val("1.2", ".") always return 1.2 double. Print Val("1,2", ",")=1.2 return true, 1.2 is a m2000 number literal and always has a dot.

\\ version 2

Module Checkit {

Checkit

 

 

From rev.31 Version 9.3 Val function update, to include a more quick version of above. We have to specify the dot char or write any two or more chars for dot to get integer part. Val function return number and in third argument (passing by reference by default) return first position in string after number. If string is empty or have no number then position is -1. If a number found position is >1. Leading spaces trimmed.

 

Function IsNumeric(a$) {

def m

Print isNumeric("1221.211.1221")=false, isNumeric("1221e1212")=false, isNumeric("1.2e4323")=false, isNumeric("-.122e-10")

 

 

=={{header|Maple}}==

try

if type(parse(s), numeric) then

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

end try:

 

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

 

=={{header|MATLAB}}==

function r = isnum(a)

r = ~isnan(str2double(a))

disp(isnum("3.1415")) % 1

 

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

(

try

)

 

 

=={{header|min}}==

{{works with|min|0.19.3}}

dup (((int integer?) (pop false)) try) dip

((float float?) (pop false)) try or

 

=={{header|MiniScript}}==

We rely on conversion to number returning a nonzero number, plus special checks for zero strings. Note that the <code>val</code> function is forgiving about additional characters ''after'' the number, so our function is too.

return s == "0" or s == "-0" or val(s) != 0

end function

print isNumeric("-3.14157")

print isNumeric("5@*#!")

 

{{out}}

 

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

 

=={{header|Nanoquery}}==

try

double(str)

return false

end

 

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

 

proc isNumeric(s: string): bool =

 

for s in Strings:

 

We could prefer to use the “parsutils” module which avoids the exception:

 

 

proc isNumeric(s: string): bool =

 

for s in Strings:

 

{{out}}

Inf is numeric

rose is not numeric</pre>

 

=={{header|Objeck}}==

class Numeric {

function : Main(args : String[]) ~ Nil {

return str->IsFloat();

}

 

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

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;

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

<span style="color: #008080;">function</span> <span style="color: #000000;">isNumber</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #7060A8;">scanf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%f"</span><span style="color: #0000FF;">)!={}</span>

<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nnot numeric: "</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">notnumb</span><span style="color: #0000FF;">,{</span><span style="color: #004600;">pp_Indent</span><span style="color: #0000FF;">,</span><span style="color: #000000;">13</span><span style="color: #0000FF;">})</span>

{{out}}

<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 %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|Plain English}}==

<code>If the string is any numeric literal,</code>

in this solution.

Start up.

Show whether "cat" is numeric.

Write the string then " -> " on the console without advancing.

If the string is any numeric literal, write "yes" on the console; exit.

{{out}}

<pre>

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>

 

===Python: Regular expressions===

numeric = re.compile('[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?')

is_numeric = lambda x: numeric.fullmatch(x) != None

 

 

=={{header|Quackery}}==

 

tuck over found iff

[ swap pluck drop ]

$ "152" task

$ "-3.1415926" task

 

{{out}}

=={{header|R}}==

 

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

[1] TRUE TRUE FALSE

 

=={{header|Racket}}==

Or, since all non-<tt>#f</tt> are true:

 

=={{header|Raku}}==

Note: These routines are usable for most cases but won't detect unicode non-digit numeric forms; E.G. vulgar fractions, Roman numerals, circled numbers, etc. If it is necessary to detect those as numeric, a full fledged grammar may be necessary.

 

$term.Numeric !~~ Failure;

}

"<$_>", .&is-number-w-ws, .&is-number-wo-ws for

(|<1 1.2 1.2.3 -6 1/2 12e B17 1.3e+12 1.3e12 -2.6e-3 zero 0x 0xA10 0b1001 0o16

 

<pre> Coerce Don't coerce

 

=={{header|RapidQ}}==

$Typecheck on

 

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

end

 

=={{header|REBOL}}==

REBOL [

Title: "Is Numeric?"

} none

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

 

=={{header|Retro}}==

Retro does not have floating point numbers as part of the core system. For others, this can be done with:

 

 

=={{header|REXX}}==

yyy=' -123.78' /*or some such. */

 

/*note: REXX only looks at the first char for DATATYPE's 2nd argument.*/

 

 

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

 

'''NB!''' Since Ruby 2.6 you no longer need `rescue`:

 

!!Float(s, exception: false)

 

Adding `exception: false` will make it return `nil` instead.

 

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

import scala.util.control.Exception.allCatch

 

def isNumber(s: String): Boolean = (allCatch opt s.toDouble).isDefined

 

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>

Simula uses the '&' instead of 'e' or 'E' for the exponent part of a floating point decimal number.

 

 

BOOLEAN PROCEDURE ISNUMERIC(W); TEXT W;

 

END

{{out}}

<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

 

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

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

--#SET TERMINATOR @

 

VALUES IS_NUMERIC('')@

VALUES IS_NUMERIC(' ')@

Output:

<pre>

 

=={{header|Standard ML}}==

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

Unix TMG dialect. NOTE: the program also performs some basic normalization (namely, removing the plus sign and translating "E" to "e"):

parse(line)\prog

parse(error)\prog;

none: <<>>;

nonl: !<<

 

Sample input:

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|True BASIC}}==

{{trans|RapidQ}}

DECLARE FUNCTION isnumeric$

 

END FUNCTION

END

 

 

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

#!/bin/bash

isnum() {

check 33.aa

check 3.3.3

 

{{out}}

 

=={{header|Ursa}}==

try

double str

return false

end try

 

=={{header|VBA}}==

So we have to check the "." or "," and replace it by the Application.DecimalSeparator.

 

Debug.Print Is_Numeric("")

Debug.Print Is_Numeric("-5.32")

Other = IIf(Separat = ",", ".", ",")

Is_Numeric = IsNumeric(Replace(s, Other, Separat))

 

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

{{libheader|Wren-fmt}}

Wren's Num class already has a static method which does what this task requires.

 

System.print("Are these strings numeric?")

var i = Num.fromString(s) // returns null if 's' is not numeric

System.print(" %(Fmt.s(4, s)) -> %((i != null) ? "yes" : "no")")

 

{{out}}

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

 

=={{header|zkl}}==

try{ text.toInt(); True }

catch{ try{ text.toFloat(); True }

catch{ False }

}

<pre>

isNum("123.4") //-->True

 

=={{header|Zoea}}==

program: numeric

case: 1 input: '1' output: true

case: 5 input: 'Fred' output: false

case: 6 input: '' output: false

 

=={{header|Zoea Visual}}==