Determine if a string is numeric: Difference between revisions
Added Vedit macro language (and let's try the lang tag) |
Add ed example |
||
(389 intermediate revisions by more than 100 users not shown) | |||
Line 1: | Line 1: | ||
{{task|Text processing}} |
{{task|Text processing}} |
||
[[Category:Simple]] |
|||
Create a boolean function which takes in a string and tells whether it is a numeric string (floating point and negative numbers included). |
|||
;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. |
|||
{{Template:Strings}} |
|||
<br><br> |
|||
=={{header|6502 Assembly}}== |
|||
For this program, a valid numeric string literal consists of only numbers (ascii $30-$39), up to one <i>leading</i> minus sign, and no more than one decimal point. Anything else, including the null string, is considered non-numeric. |
|||
Macros used (VASM syntax): |
|||
<pre> |
|||
macro loadpair,regs,addr |
|||
lda #<\addr |
|||
sta \regs |
|||
lda #>\addr |
|||
sta \regs+1 |
|||
endm |
|||
macro pushY |
|||
tya |
|||
pha |
|||
endm |
|||
macro popY |
|||
pla |
|||
tay |
|||
endm |
|||
</pre> |
|||
The code: |
|||
<syntaxhighlight lang="6502asm">*=$0801 |
|||
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 |
|||
lda #$0e |
|||
jsr chrout ;required for my printing routine to work. |
|||
z_HL equ $02 |
|||
z_L equ $02 |
|||
z_H equ $03 |
|||
z_B equ $04 |
|||
loadpair z_HL,TestString0 |
|||
jsr isStringNumeric |
|||
loadpair z_HL,TestString1 |
|||
jsr isStringNumeric |
|||
loadpair z_HL,TestString2 |
|||
jsr isStringNumeric |
|||
loadpair z_HL,TestString3 |
|||
jsr isStringNumeric |
|||
loadpair z_HL,TestString4 |
|||
jsr isStringNumeric |
|||
loadpair z_HL,TestString5 |
|||
jsr isStringNumeric |
|||
loadpair z_HL,TestString6 |
|||
jsr isStringNumeric |
|||
loadpair z_HL,TestString7 |
|||
jsr isStringNumeric |
|||
loadpair z_HL,TestString8 |
|||
jsr isStringNumeric |
|||
rts ;return to basic |
|||
isStringNumeric: |
|||
; input: z_HL = source address |
|||
pushY |
|||
ldy #0 |
|||
sty z_B ;our tally for decimal points |
|||
checkFirstChar: |
|||
lda (z_HL),y |
|||
beq notNumeric ;a null string is not a valid number! |
|||
cmp #'-' |
|||
beq isNegative_OK |
|||
cmp #'.' |
|||
beq isFloat_OK |
|||
and #$30 |
|||
cmp #$30 |
|||
beq isNumeral_OK |
|||
;else, is not numeric |
|||
notNumeric: |
|||
popY |
|||
jsr PrintString_TextScreen ;prints what's already in z_HL |
|||
jsr NewLine |
|||
loadpair z_HL,isStringNumeric_Fail |
|||
jsr PrintString_TextScreen |
|||
jsr NewLine |
|||
jmp NewLine |
|||
;rts |
|||
isNegative_OK: |
|||
isNumeral_OK: |
|||
iny |
|||
jmp loop_isStringNumeric |
|||
isFloat_OK: |
|||
iny |
|||
inc z_B |
|||
loop_isStringNumeric: |
|||
lda (z_HL),y |
|||
beq Terminated_isStringNumeric |
|||
cmp #'.' |
|||
beq CheckIfDecimalAlreadyOccurred |
|||
and #$30 |
|||
cmp #$30 |
|||
bne notNumeric |
|||
loop_overhead_isStringNumeric: |
|||
iny |
|||
jmp loop_isStringNumeric |
|||
CheckIfDecimalAlreadyOccurred: |
|||
lda z_B |
|||
bne notNumeric |
|||
inc z_B |
|||
jmp loop_overhead_isStringNumeric |
|||
Terminated_isStringNumeric: |
|||
;if we got this far the string is numeric. |
|||
popY |
|||
jsr PrintString_TextScreen ;prints what's already in z_HL |
|||
jsr NewLine |
|||
loadpair z_HL,isStringNumeric_Pass |
|||
jsr PrintString_TextScreen |
|||
jsr NewLine |
|||
jmp NewLine |
|||
;rts |
|||
isStringNumeric_Pass: |
|||
db "IS NUMERIC",0 |
|||
isStringNumeric_Fail: |
|||
db "IS NOT NUMERIC",0 |
|||
TestString0: |
|||
db 0 |
|||
TestString1: |
|||
db "123",0 |
|||
TestString2: |
|||
db "-30",0 |
|||
TestString3: |
|||
db "123.45",0 |
|||
TestString4: |
|||
db "-123.45",0 |
|||
TestString5: |
|||
db "ABCDE",0 |
|||
TestString6: |
|||
db "-34-5",0 |
|||
TestString7: |
|||
db "1.000.000",0 |
|||
TestString8: |
|||
db ".23456",0</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
ready. |
|||
load"*",8,1: |
|||
searching for * |
|||
loading |
|||
ready. |
|||
run |
|||
IS NOT NUMERIC |
|||
123 |
|||
IS NUMERIC |
|||
-30 |
|||
IS NUMERIC |
|||
123.45 |
|||
IS NUMERIC |
|||
-123.45 |
|||
IS NUMERIC |
|||
ABCDE |
|||
IS NOT NUMERIC |
|||
-34-5 |
|||
IS NOT NUMERIC |
|||
1.000.000 |
|||
IS NOT NUMERIC |
|||
.23456 |
|||
IS NUMERIC |
|||
ready. |
|||
</pre> |
|||
=={{header|8th}}== |
|||
<syntaxhighlight lang="forth">: number? >n >kind ns:n n:= ;</syntaxhighlight> |
|||
=={{header|AArch64 Assembly}}== |
|||
{{works with|as|Raspberry Pi 3B version Buster 64 bits}} |
|||
<syntaxhighlight lang="aarch64 assembly"> |
|||
/* ARM assembly Raspberry PI */ |
|||
/* program strNumber.s */ |
|||
/*******************************************/ |
|||
/* Constantes file */ |
|||
/*******************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly*/ |
|||
.include "../includeConstantesARM64.inc" |
|||
.equ BUFFERSIZE, 100 |
|||
/* Initialized data */ |
|||
.data |
|||
szMessNum: .asciz "Enter number : \n" |
|||
szMessError: .asciz "String is not a number !!!\n" |
|||
szMessInteger: .asciz "String is a integer.\n" |
|||
szMessFloat: .asciz "String is a float.\n" |
|||
szMessFloatExp: .asciz "String is a float with exposant.\n" |
|||
szCarriageReturn: .asciz "\n" |
|||
/* UnInitialized data */ |
|||
.bss |
|||
sBuffer: .skip BUFFERSIZE |
|||
/* code section */ |
|||
.text |
|||
.global main |
|||
main: |
|||
loop: |
|||
ldr x0,qAdrszMessNum |
|||
bl affichageMess |
|||
mov x0,#STDIN // Linux input console |
|||
ldr x1,qAdrsBuffer // buffer address |
|||
mov x2,#BUFFERSIZE // buffer size |
|||
mov x8, #READ // request to read datas |
|||
svc 0 // call system |
|||
ldr x1,qAdrsBuffer // buffer address |
|||
mov x2,#0 // end of string |
|||
sub x0,x0,#1 // replace character 0xA |
|||
strb w2,[x1,x0] // store byte at the end of input string (x0 contains number of characters) |
|||
ldr x0,qAdrsBuffer |
|||
bl controlNumber // call routine |
|||
cmp x0,#0 |
|||
bne 1f |
|||
ldr x0,qAdrszMessError // not a number |
|||
bl affichageMess |
|||
b 5f |
|||
1: |
|||
cmp x0,#1 |
|||
bne 2f |
|||
ldr x0,qAdrszMessInteger // integer |
|||
bl affichageMess |
|||
b 5f |
|||
2: |
|||
cmp x0,#2 |
|||
bne 3f |
|||
ldr x0,qAdrszMessFloat // float |
|||
bl affichageMess |
|||
b 5f |
|||
3: |
|||
cmp x0,#3 |
|||
bne 5f |
|||
ldr x0,qAdrszMessFloatExp // float with exposant |
|||
bl affichageMess |
|||
5: |
|||
b loop |
|||
100: // standard end of the program |
|||
mov x0, #0 // return code |
|||
mov x8, #EXIT // request to exit program |
|||
svc 0 // perform system call |
|||
qAdrszMessNum: .quad szMessNum |
|||
qAdrszMessError: .quad szMessError |
|||
qAdrszMessInteger: .quad szMessInteger |
|||
qAdrszMessFloat: .quad szMessFloat |
|||
qAdrszMessFloatExp: .quad szMessFloatExp |
|||
qAdrszCarriageReturn: .quad szCarriageReturn |
|||
qAdrsBuffer: .quad sBuffer |
|||
/******************************************************************/ |
|||
/* control if string is number */ |
|||
/******************************************************************/ |
|||
/* x0 contains the address of the string */ |
|||
/* x0 return 0 if not a number */ |
|||
/* x0 return 1 if integer eq 12345 or -12345 */ |
|||
/* x0 return 2 if float eq 123.45 or 123,45 or -123,45 */ |
|||
/* x0 return 3 if float with exposant eq 123.45E30 or -123,45E-30 */ |
|||
controlNumber: |
|||
stp x1,lr,[sp,-16]! // save registers |
|||
stp x2,x3,[sp,-16]! // save registers |
|||
stp x4,x5,[sp,-16]! // save registers |
|||
mov x1,#0 |
|||
mov x3,#0 // point counter |
|||
1: |
|||
ldrb w2,[x0,x1] |
|||
cmp x2,#0 // end string ? |
|||
beq 7f |
|||
cmp x2,#' ' // space ? |
|||
bne 3f |
|||
add x1,x1,#1 |
|||
b 1b // loop |
|||
3: |
|||
cmp x2,#'-' // negative ? |
|||
bne 4f |
|||
add x1,x1,#1 |
|||
b 5f |
|||
4: |
|||
cmp x2,#'+' // positive ? |
|||
bne 5f |
|||
add x1,x1,#1 |
|||
5: |
|||
ldrb w2,[x0,x1] // control space |
|||
cmp x2,#0 // end ? |
|||
beq 7f |
|||
cmp x2,#' ' // space ? |
|||
bne 6f |
|||
add x1,x1,#1 |
|||
b 5b // loop |
|||
6: |
|||
ldrb w2,[x0,x1] |
|||
cmp x2,#0 // end ? |
|||
beq 14f |
|||
cmp x2,#'E' // exposant ? |
|||
beq 9f |
|||
cmp x2,#'e' // exposant ? |
|||
beq 9f |
|||
cmp x2,#'.' // point ? |
|||
bne 7f |
|||
add x3,x3,#1 // yes increment counter |
|||
add x1,x1,#1 |
|||
b 6b // and loop |
|||
7: |
|||
cmp x2,#',' // comma ? |
|||
bne 8f |
|||
add x3,x3,#1 // yes increment counter |
|||
add x1,x1,#1 |
|||
b 6b // and loop |
|||
8: |
|||
cmp x2,#'0' // control digit < 0 |
|||
blt 99f |
|||
cmp x2,#'9' // control digit > 0 |
|||
bgt 99f |
|||
add x1,x1,#1 // no error loop digit |
|||
b 6b |
|||
9: // float with exposant |
|||
add x1,x1,#1 |
|||
ldrb w2,[x0,x1] |
|||
cmp x2,#0 // end ? |
|||
beq 99f |
|||
cmp x2,#'-' // negative exposant ? |
|||
bne 10f |
|||
add x1,x1,#1 |
|||
10: |
|||
mov x4,#0 // nombre de chiffres |
|||
11: |
|||
ldrb w2,[x0,x1] |
|||
cmp x2,#0 // end ? |
|||
beq 13f |
|||
cmp x2,#'0' // control digit < 0 |
|||
blt 99f |
|||
cmp x2,#'9' // control digit > 9 |
|||
bgt 99f |
|||
add x1,x1,#1 |
|||
add x4,x4,#1 // counter digit |
|||
b 11b // and loop |
|||
13: |
|||
cmp x4,#0 // number digit exposant = 0 -> error |
|||
beq 99f // error |
|||
cmp x4,#2 // number digit exposant > 2 -> error |
|||
bgt 99f // error |
|||
mov x0,#3 // valid float with exposant |
|||
b 100f |
|||
14: |
|||
cmp x3,#0 |
|||
bne 15f |
|||
mov x0,#1 // valid integer |
|||
b 100f |
|||
15: |
|||
cmp x3,#1 // number of point or comma = 1 ? |
|||
blt 100f |
|||
bgt 99f // error |
|||
mov x0,#2 // valid float |
|||
b 100f |
|||
99: |
|||
mov x0,#0 // error |
|||
100: |
|||
ldp x4,x5,[sp],16 // restaur 2 registres |
|||
ldp x2,x3,[sp],16 // restaur 2 registres |
|||
ldp x1,lr,[sp],16 // restaur 2 registres |
|||
ret |
|||
/********************************************************/ |
|||
/* File Include fonctions */ |
|||
/********************************************************/ |
|||
/* for this file see task include a file in language AArch64 assembly */ |
|||
.include "../includeARM64.inc" |
|||
</syntaxhighlight> |
|||
=={{header|Action!}}== |
|||
=== Using string <-> number conversion === |
|||
The solution below uses conversion string to number and number to string to determine if the string is numeric. |
|||
{{libheader|Action! Tool Kit}} |
|||
<syntaxhighlight lang="action!">INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit |
|||
BYTE FUNC AreEqual(CHAR ARRAY a,b) |
|||
BYTE i |
|||
IF a(0)#b(0) THEN |
|||
RETURN (0) |
|||
FI |
|||
FOR i=1 to a(0) |
|||
DO |
|||
IF a(i)#b(i) THEN |
|||
RETURN (0) |
|||
FI |
|||
OD |
|||
RETURN (1) |
|||
BYTE FUNC IsNumeric(CHAR ARRAY s) |
|||
CHAR ARRAY tmp(20) |
|||
INT i |
|||
CARD c |
|||
REAL r |
|||
i=ValI(s) |
|||
StrI(i,tmp) |
|||
IF AreEqual(s,tmp) THEN |
|||
RETURN (1) |
|||
FI |
|||
c=ValC(s) |
|||
StrC(c,tmp) |
|||
IF AreEqual(s,tmp) THEN |
|||
RETURN (1) |
|||
FI |
|||
ValR(s,r) |
|||
StrR(r,tmp) |
|||
IF AreEqual(s,tmp) THEN |
|||
RETURN (1) |
|||
FI |
|||
RETURN (0) |
|||
PROC Test(CHAR ARRAY s) |
|||
BYTE res |
|||
res=IsNumeric(s) |
|||
Print(s) |
|||
Print(" is ") |
|||
IF res=0 THEN |
|||
Print("not ") |
|||
FI |
|||
PrintE("a number.") |
|||
RETURN |
|||
PROC Main() |
|||
Put(125) PutE() ;clear the screen |
|||
Test("56233") |
|||
Test("-315") |
|||
Test("1.36") |
|||
Test("-5.126") |
|||
Test("3.7E-05") |
|||
Test("1.23BC") |
|||
Test("5.6.3") |
|||
RETURN</syntaxhighlight> |
|||
=== Using a finite-state machine === |
|||
The solution below uses a finite-state machine to determine if a string is numeric. |
|||
<syntaxhighlight lang="action!">BYTE FUNC IsSign(CHAR c) |
|||
IF c='- OR c='+ THEN |
|||
RETURN (1) |
|||
FI |
|||
RETURN (0) |
|||
BYTE FUNC IsDigit(CHAR c) |
|||
IF c>='0 AND c<='9 THEN |
|||
RETURN (1) |
|||
FI |
|||
RETURN (0) |
|||
BYTE FUNC IsDot(CHAR c) |
|||
IF c='. THEN |
|||
RETURN (1) |
|||
FI |
|||
RETURN (0) |
|||
BYTE FUNC IsExpSymbol(CHAR c) |
|||
IF c='E OR c='e THEN |
|||
RETURN (1) |
|||
FI |
|||
RETURN (0) |
|||
BYTE FUNC IsNumeric(CHAR ARRAY s) |
|||
DEFINE S_BEGIN="0" |
|||
DEFINE S_SIGN="1" |
|||
DEFINE S_BEFORE_DOT="2" |
|||
DEFINE S_DOT="3" |
|||
DEFINE S_AFTER_DOT="4" |
|||
DEFINE S_EXP_SYMBOL="5" |
|||
DEFINE S_EXP_SIGN="6" |
|||
DEFINE S_EXP="7" |
|||
BYTE i,state |
|||
CHAR c |
|||
i=1 |
|||
state=S_BEGIN |
|||
WHILE i<=s(0) |
|||
DO |
|||
c=s(i) |
|||
IF state=S_BEGIN THEN |
|||
IF IsSign(c) THEN |
|||
state=S_SIGN |
|||
ELSEIF IsDigit(c) THEN |
|||
state=S_BEFORE_DOT |
|||
ELSEIF IsDot(c) THEN |
|||
state=S_DOT |
|||
ELSE |
|||
RETURN (0) |
|||
FI |
|||
ELSEIF state=S_SIGN THEN |
|||
IF IsDigit(c) THEN |
|||
state=S_BEFORE_DOT |
|||
ELSEIF IsDot(c) THEN |
|||
state=S_DOT |
|||
ELSE |
|||
RETURN (0) |
|||
FI |
|||
ELSEIF state=S_BEFORE_DOT THEN |
|||
IF IsDigit(c) THEN |
|||
state=S_BEFORE_DOT |
|||
ELSEIF IsDot(c) THEN |
|||
state=S_DOT |
|||
ELSEIF IsExpSymbol(c) THEN |
|||
state=S_EXP_SYMBOL |
|||
ELSE |
|||
RETURN (0) |
|||
FI |
|||
ELSEIF state=S_DOT THEN |
|||
IF IsDigit(c) THEN |
|||
state=S_AFTER_DOT |
|||
ELSEIF IsExpSymbol(c) THEN |
|||
state=S_EXP_SYMBOL |
|||
ELSE |
|||
RETURN (0) |
|||
FI |
|||
ELSEIF state=S_AFTER_DOT THEN |
|||
IF IsDigit(c) THEN |
|||
state=S_AFTER_DOT |
|||
ELSEIF IsExpSymbol(c) THEN |
|||
state=S_EXP_SYMBOL |
|||
ELSE |
|||
RETURN (0) |
|||
FI |
|||
ELSEIF state=S_EXP_SYMBOL THEN |
|||
IF IsSign(c) THEN |
|||
state=S_EXP_SIGN |
|||
ELSEIF IsDigit(c) THEN |
|||
state=S_EXP |
|||
ELSE |
|||
RETURN (0) |
|||
FI |
|||
ELSEIF state=S_EXP_SIGN THEN |
|||
IF IsDigit(c) THEN |
|||
state=S_EXP |
|||
ELSE |
|||
RETURN (0) |
|||
FI |
|||
ELSEIF state=S_EXP THEN |
|||
IF IsDigit(c) THEN |
|||
state=S_EXP |
|||
ELSE |
|||
RETURN (0) |
|||
FI |
|||
ELSE |
|||
RETURN (0) |
|||
FI |
|||
i==+1 |
|||
OD |
|||
IF state=S_BEGIN OR state=S_DOT OR |
|||
state=S_EXP_SIGN OR state=S_EXP_SIGN THEN |
|||
RETURN (0) |
|||
FI |
|||
RETURN (1) |
|||
PROC Test(CHAR ARRAY s) |
|||
BYTE res |
|||
res=IsNumeric(s) |
|||
Print(s) |
|||
Print(" is ") |
|||
IF res=0 THEN |
|||
Print("not ") |
|||
FI |
|||
PrintE("a number.") |
|||
RETURN |
|||
PROC Main() |
|||
Test("56233") |
|||
Test("-315") |
|||
Test("1.36") |
|||
Test("-5.126") |
|||
Test("3.7E-05") |
|||
Test("1.23BC") |
|||
Test("5.6.3") |
|||
RETURN</syntaxhighlight> |
|||
{{out}} |
|||
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Determine_if_a_string_is_numeric_state_machine.png Screenshot from Atari 8-bit computer] |
|||
<pre> |
|||
56233 is a number. |
|||
-315 is a number. |
|||
1.36 is a number. |
|||
-5.126 is a number. |
|||
3.7E-05 is a number. |
|||
1.23BC is not a number. |
|||
5.6.3 is not a number. |
|||
</pre> |
|||
=={{header|ActionScript}}== |
=={{header|ActionScript}}== |
||
<syntaxhighlight lang="actionscript">public function isNumeric(num:String):Boolean |
|||
<lang actionscript> |
|||
public function isNumeric(num:String):Boolean |
|||
{ |
{ |
||
return !isNaN(parseInt(num)); |
return !isNaN(parseInt(num)); |
||
}</syntaxhighlight> |
|||
} |
|||
</lang> |
|||
=={{header|Ada}}== |
=={{header|Ada}}== |
||
The first file is the package interface containing the declaration of the Is_Numeric function. |
The first file is the package interface containing the declaration of the Is_Numeric function. |
||
<syntaxhighlight lang="ada">package Numeric_Tests is |
|||
<lang ada> |
|||
function Is_Numeric (Item : in String) return Boolean; |
|||
package Numeric_Tests is |
|||
end Numeric_Tests;</syntaxhighlight> |
|||
function Is_Numeric(Item : in String) return Boolean; |
|||
end Numeric_Tests; |
|||
</lang> |
|||
The second file is the package body containing the implementation of the Is_Numeric function. |
The second file is the package body containing the implementation of the Is_Numeric function. |
||
<syntaxhighlight lang="ada">package body Numeric_Tests is |
|||
<lang ada> |
|||
function Is_Numeric (Item : in String) return Boolean is |
|||
package body Numeric_Tests is |
|||
Dummy : Float; |
|||
begin |
|||
---------------- |
|||
Dummy := Float'Value (Item); |
|||
-- Is_Numeric -- |
|||
return True; |
|||
---------------- |
|||
exception |
|||
when others => |
|||
function Is_Numeric (Item : in String) return Boolean is |
|||
return False; |
|||
end Is_Numeric; |
|||
end Numeric_Tests;</syntaxhighlight> |
|||
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; |
|||
</lang> |
|||
The last file shows how the Is_Numeric function can be called. |
The last file shows how the Is_Numeric function can be called. |
||
<syntaxhighlight lang="ada">with Ada.Text_Io; use Ada.Text_Io; |
|||
<lang ada> |
|||
with Numeric_Tests; use Numeric_Tests; |
|||
with Numeric_Tests; use Numeric_Tests; |
|||
procedure Is_Numeric_Test is |
|||
S1 : String := "152"; |
|||
procedure Isnumeric_Test is |
|||
S2 : String := "-3.1415926"; |
|||
S3 : String := "Foo123"; |
|||
begin |
|||
S3 : String := "Foo123"; |
|||
Put_Line(S1 & " results in " & Boolean'Image(Is_Numeric(S1))); |
|||
begin |
|||
Put_Line(S2 & " results in " & Boolean'Image(Is_Numeric(S2))); |
|||
Put_Line(S3 & " results in " & Boolean'Image(Is_Numeric(S3))); |
|||
end Is_Numeric_Test;</syntaxhighlight> |
|||
Put_Line(S3 & " results in " & Boolean'Image(Is_Numeric(S3))); |
|||
{{out}} |
|||
end Isnumeric_Test; |
|||
< |
<pre> |
||
The output of the program above is: |
|||
152 results in TRUE |
152 results in TRUE |
||
-3.1415926 results in TRUE |
-3.1415926 results in TRUE |
||
Foo123 results in FALSE |
Foo123 results in FALSE |
||
</pre> |
|||
=={{header|Aime}}== |
|||
<syntaxhighlight lang="aime">integer |
|||
is_numeric(text s) |
|||
{ |
|||
return !trap_q(alpha, s, 0); |
|||
} |
|||
integer |
|||
main(void) |
|||
{ |
|||
if (!is_numeric("8192&*")) { |
|||
o_text("Not numeric.\n"); |
|||
} |
|||
if (is_numeric("8192")) { |
|||
o_text("Numeric.\n"); |
|||
} |
|||
return 0; |
|||
}</syntaxhighlight> |
|||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
||
{{trans|Ada}} |
|||
PROC is numeric = (REF STRING string) BOOL: ( |
|||
BOOL out := TRUE; |
|||
{{works with|ALGOL 68|Revision 1 - no extensions to language used}} |
|||
PROC call back false = (REF FILE f)BOOL: (out:= FALSE; TRUE); |
|||
{{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]}} |
|||
FILE memory; |
|||
{{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}} |
|||
associate(memory, string); |
|||
<syntaxhighlight lang="algol68">PROC is numeric = (REF STRING string) BOOL: ( |
|||
on value error(memory, call back false); |
|||
BOOL out := TRUE; |
|||
on logical file end(memory, call back false); |
|||
PROC call back false = (REF FILE f)BOOL: (out:= FALSE; TRUE); |
|||
UNION (INT, REAL, COMPLEX) numeric:=pi; |
|||
FILE memory; |
|||
# use a FORMAT pattern instead of a regular expression # |
|||
associate(memory, string); |
|||
on value error(memory, call back false); |
|||
out |
|||
on logical file end(memory, call back false); |
|||
); |
|||
UNION (INT, REAL, COMPL) numeric:=0.0; |
|||
PROC is numeric test = VOID: ( |
|||
# use a FORMAT pattern instead of a regular expression # |
|||
STRING |
|||
getf(memory, ($gl$, numeric)); |
|||
s1 := "152", |
|||
out |
|||
s2 := "-3.1415926", |
|||
); |
|||
s3 := "Foo123"; |
|||
print((s1, " results in ", is numeric(s1), new line)); |
|||
test:( |
|||
print((s2, " results in ", is numeric(s2), new line)); |
|||
STRING |
|||
print((s3, " results in ", is numeric(s3), new line)) |
|||
s1 := "152", |
|||
); |
|||
s2 := "-3.1415926", |
|||
s3 := "Foo123"; |
|||
is numeric test |
|||
print(( |
|||
Result is: |
|||
s1, " results in ", is numeric(s1), new line, |
|||
s2, " results in ", is numeric(s2), new line, |
|||
s3, " results in ", is numeric(s3), new line |
|||
)) |
|||
) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
152 results in T |
|||
-3.1415926 results in T |
|||
Foo123 results in F |
|||
</pre> |
|||
=={{header|ALGOL W}}== |
|||
<syntaxhighlight lang="algolw">begin |
|||
% determnines whether the string contains an integer, real or imaginary % |
|||
% number. Returns true if it does, false otherwise % |
|||
logical procedure isNumeric( string(32) value text ) ; |
|||
begin |
|||
logical ok; |
|||
% the "number" cannot be blank % |
|||
ok := ( text not = " " ); |
|||
if ok then begin |
|||
% there is at least one non-blank character % |
|||
% must have either an integer or real/immaginary number % |
|||
% integer: [+|-]digit-sequence % |
|||
% real: [+|-][digit-sequence].digit-sequence['integer][L] % |
|||
% or: [+|-]digit-sequence[.[digit-sequence]]'integer[L] % |
|||
% imaginary: % |
|||
% [+|-][digit-sequence].digit-sequence['integer][L]I% |
|||
% or: [+|-]digit-sequence[.[digit-sequence]]'integer[L]I% |
|||
% The "I" at the end of an imaginary number can appear % |
|||
% before or after the "L" (which indicates a long number) % |
|||
% the "I" and "L" can be in either case % |
|||
procedure nextChar ; charPos := charPos + 1; |
|||
logical procedure have( string(1) value ch ) ; |
|||
( charPos <= maxChar and text(charPos//1) = ch ) ; |
|||
logical procedure haveDigit ; |
|||
( charPos <= maxChar and text(charPos//1) >= "0" and text(charPos//1) <= "9" ) ; |
|||
integer charPos, maxChar; |
|||
logical hadDigits, isReal; |
|||
charPos := 0; |
|||
maxChar := 31; |
|||
hadDigits := false; |
|||
isReal := false; |
|||
% skip trailing spaces % |
|||
while maxChar > 0 and text(maxChar//1) = " " do maxChar := maxChar - 1; |
|||
% skip leading spacesx % |
|||
while have( " " ) do nextChar; |
|||
% skip optional sign % |
|||
if have( "+" ) or have( "-" ) then nextChar; |
|||
if haveDigit then begin |
|||
% have a digit sequence % |
|||
hadDigits := true; |
|||
while haveDigit do nextChar |
|||
end if_have_sign ; |
|||
if have( "." ) then begin |
|||
% real or imaginary number % |
|||
nextChar; |
|||
isReal := true; |
|||
hadDigits := hadDigits or haveDigit; |
|||
while haveDigit do nextChar |
|||
end if_have_point ; |
|||
% should have had some digits % |
|||
ok := hadDigits; |
|||
if ok and have( "'" ) then begin |
|||
% the number has an exponent % |
|||
isReal := true; |
|||
nextChar; |
|||
% skip optional sign % |
|||
if have( "+" ) or have( "-" ) then nextChar; |
|||
% must have a digit sequence % |
|||
ok := haveDigit; |
|||
while haveDigit do nextChar; |
|||
end if_ok_and_have_exponent ; |
|||
% if it is a real number, there could be L/I suffixes % |
|||
if ok and isReal then begin |
|||
integer LCount, ICount; |
|||
LCount := 0; |
|||
ICount := 0; |
|||
while have( "L" ) or have( "l" ) or have( "I" ) or have( "i" ) do begin |
|||
if have( "L" ) or have( "l" ) |
|||
then LCount := LCount + 1 |
|||
else ICount := ICount + 1; |
|||
nextChar |
|||
end while_have_L_or_I ; |
|||
% there can be at most one L and at most 1 I % |
|||
ok := ( LCount < 2 and ICount < 2 ) |
|||
end if_ok_and_isReal ; |
|||
% must now be at the end if the number % |
|||
ok := ok and charPos >= maxChar |
|||
end if_ok ; |
|||
ok |
|||
end isNumeric ; |
|||
% test the isNumeric procedure % |
|||
procedure testIsNumeric( string(32) value n |
|||
; logical value expectedResult |
|||
) ; |
|||
begin |
|||
logical actualResult; |
|||
actualResult := isNumeric( n ); |
|||
write( s_w := 0 |
|||
, """", n, """ is " |
|||
, if actualResult then "" else "not " |
|||
, "numeric " |
|||
, if actualResult = expectedResult then "" else " NOT " |
|||
, "as expected" |
|||
) |
|||
end testIsNumeric ; |
|||
testIsNumeric( "", false ); |
|||
testIsNumeric( "b", false ); |
|||
testIsNumeric( ".", false ); |
|||
testIsNumeric( ".'3", false ); |
|||
testIsNumeric( "3.'", false ); |
|||
testIsNumeric( "0.0z44", false ); |
|||
testIsNumeric( "-1IL", false ); |
|||
testIsNumeric( "4.5'23ILL", false ); |
|||
write( "---------" ); |
|||
testIsNumeric( "-1", true ); |
|||
testIsNumeric( " +.345", true ); |
|||
testIsNumeric( "4.5'23I", true ); |
|||
testIsNumeric( "-5'+3i", true ); |
|||
testIsNumeric( "-5'-3l", true ); |
|||
testIsNumeric( " -.345LI", true ); |
|||
end.</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
" " is not numeric as expected |
|||
"b " is not numeric as expected |
|||
". " is not numeric as expected |
|||
".'3 " is not numeric as expected |
|||
"3.' " is not numeric as expected |
|||
"0.0z44 " is not numeric as expected |
|||
"-1IL " is not numeric as expected |
|||
"4.5'23ILL " is not numeric as expected |
|||
--------- |
|||
"-1 " is numeric as expected |
|||
" +.345 " is numeric as expected |
|||
"4.5'23I " is numeric as expected |
|||
"-5'+3i " is numeric as expected |
|||
"-5'-3l " is numeric as expected |
|||
" -.345LI " is numeric as expected |
|||
</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. |
|||
<syntaxhighlight lang="apex"> |
|||
String numericString = '123456'; |
|||
String partlyNumericString = '123DMS'; |
|||
String decimalString = '123.456'; |
|||
System.debug(numericString.isNumeric()); // this will be true |
|||
System.debug(partlyNumericString.isNumeric()); // this will be false |
|||
System.debug(decimalString.isNumeric()); // this will be false |
|||
System.debug(decimalString.remove('.').isNumeric()); // this will be true |
|||
</syntaxhighlight> |
|||
=={{header|APL}}== |
=={{header|APL}}== |
||
{{works with|Dyalog APL}} |
{{works with|Dyalog APL}} |
||
⊃⎕VFI{w←⍵⋄((w='-')/w)←'¯'⋄w}'152 -3.1415926 Foo123' |
<syntaxhighlight lang="apl"> ⊃⎕VFI{w←⍵⋄((w='-')/w)←'¯'⋄w}'152 -3.1415926 Foo123' |
||
1 1 0 |
|||
1 1 0</syntaxhighlight> |
|||
Works with more recent versions of <B>Dyalog APL</B><syntaxhighlight lang="apl"> ⊃⎕VFI '¯' @ ('-'∘=) '152 -3.1415926 Foo123' ⍝ Fast: replacement of - with APL high-minus required for ⎕VFI |
|||
1 1 0 |
|||
⊃⎕VFI '-' ⎕R '¯' ⊣ '152 -3.1415926 Foo123' ⍝ Simple: (ditto) |
|||
1 1 0</syntaxhighlight> |
|||
{{works with|GNU APL}} |
|||
<syntaxhighlight lang="apl"> |
|||
{∧/⍵∊(⊃,¨'0123456789¯.+')}¨'152' '¯3.1415926' 'Foo123' |
|||
1 1 0 |
|||
</syntaxhighlight> |
|||
=={{header|AppleScript}}== |
|||
<syntaxhighlight lang="applescript"> |
|||
-- isNumString :: String -> Bool |
|||
on isNumString(s) |
|||
try |
|||
if class of s is string then |
|||
set c to class of (s as number) |
|||
c is real or c is integer |
|||
else |
|||
false |
|||
end if |
|||
on error |
|||
false |
|||
end try |
|||
end isNumString |
|||
-- TEST |
|||
on run |
|||
map(isNumString, {3, 3.0, 3.5, "3.5", "3E8", "-3.5", "30", "three", three, four}) |
|||
--> {false, false, false, true, true, true, true, false, false, false} |
|||
end run |
|||
-- three :: () -> Int |
|||
script three |
|||
3 |
|||
end script |
|||
-- four :: () -> Int |
|||
on four() |
|||
4 |
|||
end four |
|||
-- GENERIC FUNCTIONS FOR TEST |
|||
-- map :: (a -> b) -> [a] -> [b] |
|||
on map(f, xs) |
|||
tell mReturn(f) |
|||
set lng to length of xs |
|||
set lst to {} |
|||
repeat with i from 1 to lng |
|||
set end of lst to lambda(item i of xs, i, xs) |
|||
end repeat |
|||
return lst |
|||
end tell |
|||
end map |
|||
-- Lift 2nd class handler function into 1st class script wrapper |
|||
-- mReturn :: Handler -> Script |
|||
on mReturn(f) |
|||
if class of f is script then |
|||
f |
|||
else |
|||
script |
|||
property lambda : f |
|||
end script |
|||
end if |
|||
end mReturn</syntaxhighlight> |
|||
{{Out}} |
|||
<syntaxhighlight lang="applescript">{false, false, false, true, true, true, true, false, false, false}</syntaxhighlight> |
|||
The classic way's slightly simpler, since the coercion result ''must'' be a real or an integer if the coercion itself didn't error. |
|||
<syntaxhighlight lang="applescript">on isNumString(s) |
|||
if (s's class is not text) then return false |
|||
try |
|||
s as number |
|||
return true |
|||
on error |
|||
return false |
|||
end try |
|||
end isNumString</syntaxhighlight> |
|||
=={{header|ARM Assembly}}== |
|||
{{works with|as|Raspberry Pi}} |
|||
<syntaxhighlight lang="arm assembly"> |
|||
/* ARM assembly Raspberry PI */ |
|||
/* program strNumber.s */ |
|||
/* Constantes */ |
|||
.equ STDIN, 0 @ Linux input console |
|||
.equ STDOUT, 1 @ Linux output console |
|||
.equ EXIT, 1 @ Linux syscall |
|||
.equ READ, 3 @ Linux syscall |
|||
.equ WRITE, 4 @ Linux syscall |
|||
.equ BUFFERSIZE, 100 |
|||
/* Initialized data */ |
|||
.data |
|||
szMessNum: .asciz "Enter number : \n" |
|||
szMessError: .asciz "String is not a number !!!\n" |
|||
szMessInteger: .asciz "String is a integer.\n" |
|||
szMessFloat: .asciz "String is a float.\n" |
|||
szMessFloatExp: .asciz "String is a float with exposant.\n" |
|||
szCarriageReturn: .asciz "\n" |
|||
/* UnInitialized data */ |
|||
.bss |
|||
sBuffer: .skip BUFFERSIZE |
|||
/* code section */ |
|||
.text |
|||
.global main |
|||
main: |
|||
loop: |
|||
ldr r0,iAdrszMessNum |
|||
bl affichageMess |
|||
mov r0,#STDIN @ Linux input console |
|||
ldr r1,iAdrsBuffer @ buffer address |
|||
mov r2,#BUFFERSIZE @ buffer size |
|||
mov r7, #READ @ request to read datas |
|||
swi 0 @ call system |
|||
ldr r1,iAdrsBuffer @ buffer address |
|||
mov r2,#0 @ end of string |
|||
sub r0,#1 @ replace character 0xA |
|||
strb r2,[r1,r0] @ store byte at the end of input string (r0 contains number of characters) |
|||
ldr r0,iAdrsBuffer |
|||
bl controlNumber @ call routine |
|||
cmp r0,#0 |
|||
bne 1f |
|||
ldr r0,iAdrszMessError @ not a number |
|||
bl affichageMess |
|||
b 5f |
|||
1: |
|||
cmp r0,#1 |
|||
bne 2f |
|||
ldr r0,iAdrszMessInteger @ integer |
|||
bl affichageMess |
|||
b 5f |
|||
2: |
|||
cmp r0,#2 |
|||
bne 3f |
|||
ldr r0,iAdrszMessFloat @ float |
|||
bl affichageMess |
|||
b 5f |
|||
3: |
|||
cmp r0,#3 |
|||
bne 5f |
|||
ldr r0,iAdrszMessFloatExp @ float with exposant |
|||
bl affichageMess |
|||
5: |
|||
b loop |
|||
100: @ standard end of the program |
|||
mov r0, #0 @ return code |
|||
mov r7, #EXIT @ request to exit program |
|||
svc 0 @ perform system call |
|||
iAdrszMessNum: .int szMessNum |
|||
iAdrszMessError: .int szMessError |
|||
iAdrszMessInteger: .int szMessInteger |
|||
iAdrszMessFloat: .int szMessFloat |
|||
iAdrszMessFloatExp: .int szMessFloatExp |
|||
iAdrszCarriageReturn: .int szCarriageReturn |
|||
iAdrsBuffer: .int sBuffer |
|||
/******************************************************************/ |
|||
/* control if string is number */ |
|||
/******************************************************************/ |
|||
/* r0 contains the address of the string */ |
|||
/* r0 return 0 if not a number */ |
|||
/* r0 return 1 if integer eq 12345 or -12345 */ |
|||
/* r0 return 2 if float eq 123.45 or 123,45 or -123,45 */ |
|||
/* r0 return 3 if float with exposant eq 123.45E30 or -123,45E-30 */ |
|||
controlNumber: |
|||
push {r1-r4,lr} @ save registers |
|||
mov r1,#0 |
|||
mov r3,#0 @ point counter |
|||
1: |
|||
ldrb r2,[r0,r1] |
|||
cmp r2,#0 |
|||
beq 5f |
|||
cmp r2,#' ' |
|||
addeq r1,#1 |
|||
beq 1b |
|||
cmp r2,#'-' @ negative ? |
|||
addeq r1,#1 |
|||
beq 2f |
|||
cmp r2,#'+' @ positive ? |
|||
addeq r1,#1 |
|||
2: |
|||
ldrb r2,[r0,r1] @ control space |
|||
cmp r2,#0 @ end ? |
|||
beq 5f |
|||
cmp r2,#' ' |
|||
addeq r1,#1 |
|||
beq 2b |
|||
3: |
|||
ldrb r2,[r0,r1] |
|||
cmp r2,#0 @ end ? |
|||
beq 10f |
|||
cmp r2,#'E' @ exposant ? |
|||
beq 6f |
|||
cmp r2,#'e' @ exposant ? |
|||
beq 6f |
|||
cmp r2,#'.' @ point ? |
|||
addeq r3,#1 @ yes increment counter |
|||
addeq r1,#1 |
|||
beq 3b |
|||
cmp r2,#',' @ comma ? |
|||
addeq r3,#1 @ yes increment counter |
|||
addeq r1,#1 |
|||
beq 3b |
|||
cmp r2,#'0' @ control digit < 0 |
|||
blt 5f |
|||
cmp r2,#'9' @ control digit > 0 |
|||
bgt 5f |
|||
add r1,#1 @ no error loop digit |
|||
b 3b |
|||
5: @ error detected |
|||
mov r0,#0 |
|||
b 100f |
|||
6: @ float with exposant |
|||
add r1,#1 |
|||
ldrb r2,[r0,r1] |
|||
cmp r2,#0 @ end ? |
|||
moveq r0,#0 @ error |
|||
beq 100f |
|||
cmp r2,#'-' @ negative exposant ? |
|||
addeq r1,#1 |
|||
mov r4,#0 @ nombre de chiffres |
|||
7: |
|||
ldrb r2,[r0,r1] |
|||
cmp r2,#0 @ end ? |
|||
beq 9f |
|||
cmp r2,#'0' @ control digit < 0 |
|||
blt 8f |
|||
cmp r2,#'9' @ control digit > 0 |
|||
bgt 8f |
|||
add r1,#1 |
|||
add r4,#1 @ counter digit |
|||
b 7b |
|||
8: |
|||
mov r0,#0 |
|||
b 100f |
|||
9: |
|||
cmp r4,#0 @ number digit exposant = 0 -> error |
|||
moveq r0,#0 @ erreur |
|||
beq 100f |
|||
cmp r4,#2 @ number digit exposant > 2 -> error |
|||
movgt r0,#0 @ error |
|||
bgt 100f |
|||
mov r0,#3 @ valid float with exposant |
|||
b 100f |
|||
10: |
|||
cmp r3,#0 |
|||
moveq r0,#1 @ valid integer |
|||
beq 100f |
|||
cmp r3,#1 @ number of point or comma = 1 ? |
|||
moveq r0,#2 @ valid float |
|||
movgt r0,#0 @ error |
|||
100: |
|||
pop {r1-r4,lr} @ restaur des 2 registres |
|||
bx lr @ return |
|||
/******************************************************************/ |
|||
/* display text with size calculation */ |
|||
/******************************************************************/ |
|||
/* r0 contains the address of the message */ |
|||
affichageMess: |
|||
push {r0,r1,r2,r7,lr} @ save registers |
|||
mov r2,#0 @ counter length */ |
|||
1: @ loop length calculation |
|||
ldrb r1,[r0,r2] @ read octet start position + index |
|||
cmp r1,#0 @ if 0 its over |
|||
addne r2,r2,#1 @ else add 1 in the length |
|||
bne 1b @ and loop |
|||
@ so here r2 contains the length of the message |
|||
mov r1,r0 @ address message in r1 |
|||
mov r0,#STDOUT @ code to write to the standard output Linux |
|||
mov r7, #WRITE @ code call system "write" |
|||
svc #0 @ call system |
|||
pop {r0,r1,r2,r7,lr} @ restaur registers |
|||
bx lr @ return |
|||
</syntaxhighlight> |
|||
=={{header|Arturo}}== |
|||
<syntaxhighlight lang="rebol">print numeric? "hello world" |
|||
print numeric? "1234" |
|||
print numeric? "1234 hello world" |
|||
print numeric? "12.34" |
|||
print numeric? "!#@$" |
|||
print numeric? "-1.23"</syntaxhighlight> |
|||
{{out}} |
|||
<pre>false |
|||
true |
|||
false |
|||
true |
|||
false |
|||
true</pre> |
|||
=={{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. |
|||
<syntaxhighlight lang="autohotkey">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</syntaxhighlight> |
|||
=={{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: |
|||
<syntaxhighlight lang="awk"> |
|||
$ awk 'function isnum(x){return(x==x+0)} BEGIN{print isnum("hello"),isnum("-42")}' |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
0 1 |
|||
</pre> |
|||
=={{header|BaCon}}== |
|||
<syntaxhighlight lang="bacon">INPUT "Your string: ", s$ |
|||
IF REGEX(s$, "^[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$") THEN |
|||
PRINT "This is a number" |
|||
ELSE |
|||
PRINT "Not a number" |
|||
ENDIF</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
user@host $ ./isnumber |
|||
Your string: 12.3 |
|||
This is a number |
|||
user@host $ ./isnumber |
|||
Your string: 12E3 |
|||
This is a number |
|||
user@host $ ./isnumber |
|||
Your string: PI |
|||
Not a number |
|||
user@host $ ./isnumber |
|||
Your string: Hello |
|||
Not a number |
|||
</pre> |
|||
=={{header|BASIC}}== |
|||
<syntaxhighlight lang="qbasic">10 INPUT "Enter a string";S$:GOSUB 1000 |
|||
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$ |
|||
1099 RETURN</syntaxhighlight> |
|||
==={{header|BASIC256}}=== |
|||
<syntaxhighlight lang="basic256"> |
|||
#La función isNumeric() es nativa de BASIC256. |
|||
#Devuelve 1 (verdadero) si la expresión es un entero, |
|||
#un número de punto flotante o una cadena que se puede |
|||
#convertir directamente en un número. |
|||
#De lo contrario, devuelve 0 (falso). |
|||
#Las siguientes cadenas numéricas son válidas: |
|||
#“123”, “-345”, “234.234324”, “-34234.123”, “-2.567e7” y “6.7888E-8”. |
|||
s = "1234.056789" |
|||
print s, " => "; isNumeric(s) |
|||
s = "-2.567e7" |
|||
print s, " => "; isNumeric(s) |
|||
s = "Dog" |
|||
print s, " => "; isNumeric(s) |
|||
s = "Bad125" |
|||
print s, " => "; isNumeric(s) |
|||
s = "-0177" |
|||
print s, " => "; isNumeric(s) |
|||
s = "0b1110" #binario |
|||
print s, " => "; isNumeric(s) |
|||
s = "0o177" #octal |
|||
print s, " => "; isNumeric(s) |
|||
s = "0xff" #hexadecimal |
|||
print s, " => "; isNumeric(s) |
|||
end |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1234.056789 => 1 |
|||
-2.567e7 => 1 |
|||
Dog => 0 |
|||
Bad125 => 0 |
|||
-0177 => 1 |
|||
0b1110 => 1 |
|||
0o177 => 1 |
|||
0xff => 0 |
|||
</pre> |
|||
==={{header|Commodore BASIC}}=== |
|||
<syntaxhighlight lang="commodorebasic">5 print chr$(147);chr$(14) |
|||
10 input "Enter a string";s$:gosub 1000:print |
|||
20 if r then print "You entered a number.":goto 99 |
|||
30 print "That is not a number." |
|||
99 end |
|||
1000 t1=val(s$):t1$=str$(t1) |
|||
1010 r=t1$=s$ or t1$=" "+s$ |
|||
1099 return</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Enter a string? 15893 |
|||
You entered a number. |
|||
ready. |
|||
run |
|||
Enter a string? Llamas |
|||
That is not a number. |
|||
ready. |
|||
█</pre> |
|||
==={{header|QB64}}=== |
|||
<syntaxhighlight lang="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. |
|||
If v$ = Str$(Val(v$)) Then 'Str$() converts numeric values to their string counter parts and Val() does the opposite, |
|||
'converting strings to their numerical values. By converting the value of whatever is stored |
|||
'in v$ to a number and then back to a string it will have either stayed completely the same, |
|||
'in which case it is a numeric value (including exponent and hex and oct based numbers) or |
|||
'what is returned by the nested Str$() and Val$() functions will be different, in which case |
|||
'one, the other, or both returned an error or a truncation of the original string which began |
|||
'with numeric characters but was not entirely a number, such as "99, rue de Rivoli". |
|||
Print "Your entered a number." |
|||
Else |
|||
Print "You did not enter a number." |
|||
End If |
|||
Sleep |
|||
System |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Enter a text or a number: 12345 |
|||
You entered a number. |
|||
Enter a text or a number: Four |
|||
You did not enter a number. |
|||
Enter a text or a number: 99, rue de Rivoli |
|||
You did not enter a number. |
|||
Enter a text or a number: 9E4 |
|||
You entered a number.</pre> |
|||
NB: While "99, rue de Rivoli" contains a number it is not a number entirely. The Val(v$) in this case would have stopped after it converted the "99" portion of the input, which when converted back to a string and compared to the original input would not result in an equality. 9E4 the program reads as an exponential value. |
|||
==={{header|SmallBASIC}}=== |
|||
y = isnumber(s) returns true if s is a number or can be converted to a number. |
|||
<syntaxhighlight lang="qbasic"> |
|||
a = 1.2345 |
|||
b = "abc" |
|||
c = "-1.2345" |
|||
print isnumber(a) |
|||
print isnumber(b) |
|||
print isnumber(c) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1 |
|||
0 |
|||
1 |
|||
</pre> |
|||
=={{header|Batch File}}== |
|||
<syntaxhighlight lang="dos">set /a a=%arg%+0 >nul |
|||
if %a% == 0 ( |
|||
if not "%arg%"=="0" ( |
|||
echo Non Numeric. |
|||
) else ( |
|||
echo Numeric. |
|||
) |
|||
) else ( |
|||
echo Numeric. |
|||
)</syntaxhighlight> |
|||
=={{header|BBC BASIC}}== |
|||
{{works with|BBC BASIC for Windows}} |
|||
<syntaxhighlight lang="bbcbasic"> REPEAT |
|||
READ N$ |
|||
IF FN_isanumber(N$) THEN |
|||
PRINT "'" N$ "' is a number" |
|||
ELSE |
|||
PRINT "'" N$ "' is NOT a number" |
|||
ENDIF |
|||
UNTIL N$ = "end" |
|||
END |
|||
DATA "PI", "0123", "-0123", "12.30", "-12.30", "123!", "0" |
|||
DATA "0.0", ".123", "-.123", "12E3", "12E-3", "12+3", "end" |
|||
DEF FN_isanumber(A$) |
|||
ON ERROR LOCAL = FALSE |
|||
IF EVAL("(" + A$ + ")") <> VAL(A$) THEN = FALSE |
|||
IF VAL(A$) <> 0 THEN = TRUE |
|||
IF LEFT$(A$,1) = "0" THEN = TRUE |
|||
= FALSE |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>'PI' is NOT a number |
|||
'0123' is a number |
|||
'-0123' is a number |
|||
'12.30' is a number |
|||
'-12.30' is a number |
|||
'123!' is NOT a number |
|||
'0' is a number |
|||
'0.0' is a number |
|||
'.123' is a number |
|||
'-.123' is a number |
|||
'12E3' is a number |
|||
'12E-3' is a number |
|||
'12+3' is NOT a number |
|||
'end' is NOT a number</pre> |
|||
=={{header|Befunge}}== |
|||
<syntaxhighlight lang="befunge"> ~:0\`#v_:"+"-!#v_:"-"-!#v_::"E"-\"e"-*#v_ v |
|||
v _v# < < 0< |
|||
>~:0\`#v_>::"0"-0\`\"9"-0`+!#v_:"."-!#v_::"E"-\"e"-*!#v_ v |
|||
^ $< > > $ v |
|||
>~:0\`#v_>::"0"-0\`\"9"-0`+!#v_:"."-!#v_::"E"-\"e"-*!#v_> v> |
|||
^ $< >$~:0\`#v_:"+"-#v_v |
|||
v $_v# < < :#< |
|||
>~:0\`#v_>::"0"-0\`\"9"-0`+!#v_:"."-!#v_::"E"-\"e"-*!v 0 > v |
|||
^ $< v < << ^_^#-"-"< |
|||
> "ciremuN">:#,_@ >>#$_"ciremun toN">:#,_@^ <</syntaxhighlight> |
|||
Although only integer inputs are strictly allowed in Befunge, the code tries to adhere to the floating point conventions in other languages when recognising valid numbers. |
|||
{{out}} |
|||
<pre> |
|||
'PI' Not numeric |
|||
'0123' Numeric |
|||
'-0123' Numeric |
|||
'12.30' Numeric |
|||
'-12.30' Numeric |
|||
'123!' Not numeric |
|||
'0' Numeric |
|||
'0.0' Numeric |
|||
'.123' Numeric |
|||
'-.123' Numeric |
|||
'12E3' Numeric |
|||
'12E-3' Numeric |
|||
'12+3' Not numeric |
|||
'end' Not numeric |
|||
'12..34' Not numeric |
|||
'12e3.4' Not numeric |
|||
'192.168.0.1' Not numeric |
|||
</pre> |
|||
=={{header|BQN}}== |
|||
<syntaxhighlight lang="bqn">IsNumeric ← 1∘•ParseFloat⎊0</syntaxhighlight> |
|||
=={{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'. |
|||
<syntaxhighlight lang="bracmat">43257349578692:/ |
|||
F |
|||
260780243875083/35587980:/ |
|||
S |
|||
247/30:~/# |
|||
F |
|||
80000000000:~/# |
|||
S</syntaxhighlight> |
|||
The pattern <code>~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)</code> recognises string representations of floating point numbers. |
|||
<syntaxhighlight lang="bracmat">@("1.000-4E-10":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)) |
|||
F |
|||
@("1.0004E-54328":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)) |
|||
S |
|||
@("-464641.0004E-54328":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)) |
|||
S |
|||
@("1/2.0004E-10":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)) |
|||
F |
|||
@("1357E-10":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)) |
|||
S |
|||
@("1357e0":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)) |
|||
S |
|||
@("13579":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)) |
|||
S |
|||
@("1.246":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)) |
|||
S |
|||
@("0.0":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)) |
|||
S |
|||
@("0.0000":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)) |
|||
S</syntaxhighlight> |
|||
Calculations with floating point numbers are delegated to UFP (Un-I-fancy-fied Floating Point, because it took me 30 years to dream up a viable way to do FP in Bracmat without breaking existing code) objects. An UFP object compiles and executes code that only handles C "doubles" and (multidimensional) arrays of such values. |
|||
=={{header|Burlesque}}== |
|||
<syntaxhighlight lang="burlesque"> |
|||
ps^^-]to{"Int""Double"}\/~[\/L[1==?* |
|||
</syntaxhighlight> |
|||
Assumes string is not empty. |
|||
=={{header|C}}== |
=={{header|C}}== |
||
Returns true (non-zero) if character-string parameter represents a signed or unsigned |
Returns true (non-zero) if character-string parameter represents a signed or unsigned floating-point number. Otherwise returns false (zero). |
||
<syntaxhighlight lang="c">#include <ctype.h> |
|||
<lang c> |
|||
#include <stdbool.h> |
|||
#include <stdlib.h> |
#include <stdlib.h> |
||
int isNumeric (const char * s) |
|||
bool isNumeric(const char *s) { |
|||
{ |
|||
if ( |
if (s == NULL || *s == '\0' || isspace(*s)) { |
||
return |
return false; |
||
} |
|||
char *p; |
|||
strtod(s, &p); |
|||
return *p == '\0'; |
|||
} |
|||
}</syntaxhighlight> |
|||
</lang> |
|||
=={{header|C sharp|C#}}== |
=={{header|C sharp|C#}}== |
||
'''Framework:''' [[.NET]] 2.0+ |
'''Framework:''' [[.NET]] 2.0+ |
||
<syntaxhighlight lang="csharp">public static bool IsNumeric(string s) |
|||
<lang csharp> |
|||
public static bool IsNumeric(string s) |
|||
{ |
{ |
||
double Result; |
double Result; |
||
Line 138: | Line 1,575: | ||
{ |
{ |
||
// do something |
// do something |
||
}</syntaxhighlight> |
|||
} |
|||
</lang> |
|||
'''Framework:''' [[.NET]] 1.0+ |
'''Framework:''' [[.NET]] 1.0+ |
||
<syntaxhighlight lang="csharp">public static bool IsNumeric(string s) |
|||
<lang csharp> |
|||
using System.Text.RegularExpressions; |
|||
public static bool IsNumeric(string s) |
|||
{ |
{ |
||
try |
try |
||
Line 157: | Line 1,590: | ||
return false; |
return false; |
||
} |
} |
||
}</syntaxhighlight> |
|||
=={{header|C++}}== |
|||
{{trans|C}}<syntaxhighlight lang="cpp">#include <cctype> |
|||
#include <cstdlib> |
|||
bool isNumeric(const char *s) { |
|||
if (s == nullptr || *s == '\0' || std::isspace(*s)) { |
|||
return false; |
|||
} |
|||
char *p; |
|||
std::strtod(s, &p); |
|||
return *p == '\0'; |
|||
}</syntaxhighlight> |
|||
Using stringstream: |
|||
<syntaxhighlight lang="cpp">#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 ); |
|||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
Using find: |
|||
<syntaxhighlight lang="cpp"> |
|||
bool isNumeric( const char* pszInput, int nNumberBase ) |
|||
{ |
|||
string base = "0123456789ABCDEF"; |
|||
string input = pszInput; |
|||
return (input.find_first_not_of(base.substr(0, nNumberBase)) == string::npos); |
|||
} |
|||
</syntaxhighlight> |
|||
Using all_of (requires C++11) |
|||
<syntaxhighlight lang="cpp"> |
|||
bool isNumeric(const std::string& input) { |
|||
return std::all_of(input.begin(), input.end(), ::isdigit); |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|CFScript}}== |
|||
ColdFusion Script (CfScript) |
|||
<syntaxhighlight lang="cfm">isNumeric(42)</syntaxhighlight> |
|||
=={{header|Clojure}}== |
|||
<syntaxhighlight lang="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))))</syntaxhighlight> |
|||
This works with any sequence of characters, not just Strings, e.g.: |
|||
<syntaxhighlight lang="clojure">(numeric? [\1 \2 \3]) ;; yields logical true</syntaxhighlight> |
|||
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: |
|||
<syntaxhighlight lang="clojure"> |
|||
(require '[clojure.edn :as edn]) |
|||
(import [java.io PushbackReader StringReader]) |
|||
(defn number-string? [s] |
|||
(boolean |
|||
(when (and (string? s) (re-matches #"^[+-]?\d.*" s)) |
|||
(let [reader (PushbackReader. (StringReader. s)) |
|||
num (try (edn/read reader) (catch Exception _ nil))] |
|||
(when num |
|||
; Check that the string has nothing after the number |
|||
(= -1 (.read reader))))))) |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="clojure"> |
|||
user=> (number-string? "2r101010") |
|||
true |
|||
user=> (number-string? "22/7") |
|||
true |
|||
</syntaxhighlight> |
|||
=={{header|COBOL}}== |
|||
===Intrinsic Functions=== |
|||
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. |
|||
<syntaxhighlight lang="cobol"> program-id. is-numeric. |
|||
procedure division. |
|||
display function test-numval-f("abc") end-display |
|||
display function test-numval-f("-123.01E+3") end-display |
|||
if function test-numval-f("+123.123") equal zero then |
|||
display "is numeric" end-display |
|||
else |
|||
display "failed numval-f test" end-display |
|||
end-if |
|||
goback.</syntaxhighlight> |
|||
===Implementation=== |
|||
{{works with|OpenCOBOL}} |
|||
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION. |
|||
PROGRAM-ID. Is-Numeric. |
|||
DATA DIVISION. |
|||
WORKING-STORAGE SECTION. |
|||
01 Numeric-Chars PIC X(10) VALUE "0123456789". |
|||
01 Success CONSTANT 0. |
|||
01 Failure CONSTANT 128. |
|||
LOCAL-STORAGE SECTION. |
|||
01 I PIC 99. |
|||
01 Num-Decimal-Points PIC 99. |
|||
01 Num-Valid-Chars PIC 99. |
|||
LINKAGE SECTION. |
|||
01 Str PIC X(30). |
|||
PROCEDURE DIVISION USING Str. |
|||
IF Str = SPACES |
|||
MOVE Failure TO Return-Code |
|||
GOBACK |
|||
END-IF |
|||
MOVE FUNCTION TRIM(Str) TO Str |
|||
INSPECT Str TALLYING Num-Decimal-Points FOR ALL "." |
|||
IF Num-Decimal-Points > 1 |
|||
MOVE Failure TO Return-Code |
|||
GOBACK |
|||
ELSE |
|||
ADD Num-Decimal-Points TO Num-Valid-Chars |
|||
END-IF |
|||
IF Str (1:1) = "-" OR "+" |
|||
ADD 1 TO Num-Valid-Chars |
|||
END-IF |
|||
PERFORM VARYING I FROM 1 BY 1 UNTIL I > 10 |
|||
INSPECT Str TALLYING Num-Valid-Chars |
|||
FOR ALL Numeric-Chars (I:1) BEFORE SPACE |
|||
END-PERFORM |
|||
INSPECT Str TALLYING Num-Valid-Chars FOR TRAILING SPACES |
|||
IF Num-Valid-Chars = FUNCTION LENGTH(Str) |
|||
MOVE Success TO Return-Code |
|||
ELSE |
|||
MOVE Failure TO Return-Code |
|||
END-IF |
|||
GOBACK |
|||
.</syntaxhighlight> |
|||
=={{header|CoffeeScript}}== |
|||
The isFinite function is built into JavaScript, so we don't need to create our own function in CoffeeScript. |
|||
<syntaxhighlight lang="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 |
|||
</syntaxhighlight> |
|||
=={{header|ColdFusion}}== |
=={{header|ColdFusion}}== |
||
Adobe's ColdFusion |
Adobe's ColdFusion |
||
<syntaxhighlight lang="cfm"><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></syntaxhighlight> |
|||
===Alternative solution=== |
|||
<syntaxhighlight lang="text"><cfoutput>#isNumeric(42)#</cfoutput></syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="lisp">(defun numeric-string-p (string) |
|||
(let ((*read-eval* nil)) |
|||
(ignore-errors (numberp (read-from-string string)))))</syntaxhighlight> |
|||
<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>. |
|||
<syntaxhighlight lang="lisp">(defun numeric-string-p (string) |
|||
(ignore-errors (parse-number:parse-number string))) ; parse failed, return false (nil)</syntaxhighlight> |
|||
=={{header|D}}== |
=={{header|D}}== |
||
===Standard Version=== |
|||
<lang d> |
|||
Using the standard Phobos function (currently binary and hex literals are not recognized): |
|||
import std.stdio, std.string, std.conv, std.regexp; |
|||
<syntaxhighlight lang="d">import std.stdio, std.string, std.array; |
|||
bool isNumeric(string s) { |
|||
try |
|||
toDouble(s.strip()); |
|||
catch (Error e) |
|||
return false; |
|||
return true; |
|||
} |
|||
void main() { |
|||
foreach ( |
foreach (const s; ["12", " 12\t", "hello12", "-12", "02", |
||
"0-12", "+12", "1.5", "1,000", "1_000", |
|||
"0x10", "0b10101111_11110000_11110000_00110011", |
|||
continue; |
|||
"-0b10101", "0x10.5"]) |
|||
writefln(`isNumeric("%s"): %s`, s, s.strip().isNumeric(true)); |
|||
continue; |
|||
}</syntaxhighlight> |
|||
return |
|||
{{out}} |
|||
false; |
|||
<pre>isNumeric("12"): true |
|||
isNumeric(" 12 "): true |
|||
isNumeric("hello12"): false |
|||
isNumeric("-12"): true |
|||
isNumeric("02"): true |
|||
isNumeric("0-12"): false |
|||
isNumeric("+12"): true |
|||
isNumeric("1.5"): true |
|||
isNumeric("1,000"): true |
|||
isNumeric("1_000"): true |
|||
isNumeric("0x10"): false |
|||
isNumeric("0b10101111_11110000_11110000_00110011"): false |
|||
isNumeric("-0b10101"): false |
|||
isNumeric("0x10.5"): false</pre> |
|||
===An Implementation=== |
|||
<syntaxhighlight lang="d">import std.stdio, std.string, std.conv, std.array, std.exception; |
|||
bool isNumeric(in string s) pure { |
|||
immutable s2 = s.strip.toLower.replace("_", "").replace(",", ""); |
|||
try { |
|||
s2.to!real; |
|||
} catch (ConvException e) { |
|||
if (s2.startsWith("0x")) |
|||
return !s2[2 .. $].to!ulong(16) |
|||
.collectException!ConvException; |
|||
else if (s2.startsWith("0b")) |
|||
return !s2[2 .. $].to!ulong(2) |
|||
.collectException!ConvException; |
|||
else |
|||
return false; |
|||
} |
} |
||
return true; |
return true; |
||
} |
} |
||
void main() { |
|||
foreach (immutable s; ["12", " 12\t", "hello12", "-12", "02", |
|||
return cast(bool)search(s, r"^[-+]?\d+$"); |
|||
"0-12", "+12", "1.5", "1,000", "1_000", |
|||
"0x10", "0b10101111_11110000_11110000_00110011", |
|||
"-0b10101", "0x10.5"]) |
|||
writefln(`isNumeric("%s"): %s`, s, s.isNumeric); |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre>isNumeric("12"): true |
|||
isNumeric(" 12 "): true |
|||
isNumeric("hello12"): false |
|||
isNumeric("-12"): true |
|||
isNumeric("02"): true |
|||
isNumeric("0-12"): false |
|||
isNumeric("+12"): true |
|||
isNumeric("1.5"): true |
|||
isNumeric("1,000"): true |
|||
isNumeric("1_000"): true |
|||
isNumeric("0x10"): true |
|||
isNumeric("0b10101111_11110000_11110000_00110011"): true |
|||
isNumeric("-0b10101"): false |
|||
isNumeric("0x10.5"): false</pre> |
|||
=={{header|Delphi}}== |
|||
This simple function is a wrapper around a built-in Delphi function |
|||
<syntaxhighlight lang="delphi"> |
|||
function IsNumericString(const inStr: string): Boolean; |
|||
var |
|||
i: extended; |
|||
begin |
|||
Result := TryStrToFloat(inStr,i); |
|||
end; |
|||
</syntaxhighlight> |
|||
This console application tests the function: |
|||
<syntaxhighlight lang="delphi"> |
|||
program isNumeric; |
|||
{$APPTYPE CONSOLE} |
|||
uses |
|||
Classes, |
|||
SysUtils; |
|||
function IsNumericString(const inStr: string): Boolean; |
|||
var |
|||
i: extended; |
|||
begin |
|||
Result := TryStrToFloat(inStr,i); |
|||
end; |
|||
{ Test function } |
|||
var |
|||
s: string; |
|||
c: Integer; |
|||
const |
|||
MAX_TRIES = 10; |
|||
sPROMPT = 'Enter a string (or type "quit" to exit):'; |
|||
sIS = ' is numeric'; |
|||
sISNOT = ' is NOT numeric'; |
|||
begin |
|||
c := 0; |
|||
s := ''; |
|||
repeat |
|||
Inc(c); |
|||
Writeln(sPROMPT); |
|||
Readln(s); |
|||
if (s <> '') then |
|||
begin |
|||
tmp.Add(s); |
|||
if IsNumericString(s) then |
|||
begin |
|||
Writeln(s+sIS); |
|||
end |
|||
else |
|||
begin |
|||
Writeln(s+sISNOT); |
|||
end; |
|||
Writeln(''); |
|||
end; |
|||
until |
|||
(c >= MAX_TRIES) or (LowerCase(s) = 'quit'); |
|||
end. |
|||
</syntaxhighlight> |
|||
{{out}} Example summarised: |
|||
<pre> |
|||
123 is numeric |
|||
-123.456 is numeric |
|||
-123.-456 is NOT numeric |
|||
.345 is numeric |
|||
m1k3 is NOT numeric |
|||
</pre> |
|||
=={{header|Dyalect}}== |
|||
<syntaxhighlight lang="dyalect">func String.IsNumeric() { |
|||
try { |
|||
parse(this) is Integer or Float |
|||
} catch _ { |
|||
false |
|||
} |
|||
} |
} |
||
var str = "1234567" |
|||
print(str.IsNumeric())</syntaxhighlight> |
|||
=={{header|Déjà Vu}}== |
|||
bool isInt3(string s) { |
|||
<syntaxhighlight lang="dejavu">is-numeric s: |
|||
try |
|||
true |
|||
toInt(s.strip()); |
|||
try: |
|||
catch (Error e) |
|||
drop to-num s |
|||
return false; |
|||
catch value-error: |
|||
return true; |
|||
not |
|||
for v in [ "1" "0" "3.14" "hello" "12e3" "12ef" "-3" ]: |
|||
!.( v is-numeric v )</syntaxhighlight> |
|||
{{out}} |
|||
<pre>"-3" true |
|||
"12ef" false |
|||
"12e3" true |
|||
"hello" false |
|||
"3.14" true |
|||
"0" true |
|||
"1" true</pre> |
|||
=={{header|E}}== |
|||
<syntaxhighlight lang="e">def isNumeric(specimen :String) { |
|||
try { |
|||
<import:java.lang.makeDouble>.valueOf(specimen) |
|||
return true |
|||
} catch _ { |
|||
return false |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|EasyLang}}== |
|||
<syntaxhighlight lang="text"> |
|||
func is_numeric a$ . |
|||
h = number a$ |
|||
# because every variable must be used |
|||
h = h |
|||
return 1 - error |
|||
. |
|||
for s$ in [ "abc" "21a" "1234" "-13" "7.65" ] |
|||
if is_numeric s$ = 1 |
|||
print s$ & " is numeric" |
|||
else |
|||
print s$ & " is not numeric" |
|||
. |
|||
. |
|||
</syntaxhighlight> |
|||
=={{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 |
|||
<syntaxhighlight lang="scheme"> |
|||
(string->number "albert") |
|||
→ #f |
|||
(string->number -666) |
|||
→ -666 |
|||
(if (string->number 666) 'YES 'NO) |
|||
→ YES |
|||
</syntaxhighlight> |
|||
=={{header|Ed}}== |
|||
<syntaxhighlight lang="sed"> |
|||
H |
|||
g/^([-+]?[0-9]*)(\.[0-9]+([eE][+-]?[0-9]+)?)?$/s//\1\2 is numeric/ |
|||
v/numeric/s/.*/& is not numeric/ |
|||
,p |
|||
Q |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>$ cat string-numeric.ed | ed -GlEs string-numeric.input |
|||
Newline appended |
|||
56233 is numeric |
|||
-315 is numeric |
|||
1.36 is numeric |
|||
-5.126 is numeric |
|||
3.7E-05 is numeric |
|||
1.23BC is not numeric |
|||
5.6.3 is not numeric</pre> |
|||
=={{header|Elixir}}== |
|||
<syntaxhighlight lang="elixir">defmodule RC do |
|||
def is_numeric(str) do |
|||
case Float.parse(str) do |
|||
{_num, ""} -> true |
|||
_ -> false |
|||
end |
|||
end |
|||
end |
|||
["123", "-12.3", "123.", ".05", "-12e5", "+123", " 123", "abc", "123a", "12.3e", "1 2"] |> Enum.filter(&RC.is_numeric/1)</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
["123", "-12.3", "-12e5", "+123"] |
|||
</pre> |
|||
=={{header|Emacs Lisp}}== |
|||
<syntaxhighlight lang="lisp"> |
|||
(defun string-valid-number-p (str) |
|||
"Test if STR is a numeric string. |
|||
Eliminate strings with commas in them because ELisp numbers do |
|||
not contain commas. Then check if remaining strings would be |
|||
valid ELisp numbers if the quotation marks were removed." |
|||
(and |
|||
;; no comma in string, because ELisp numbers do not have commas |
|||
;; we need to eliminate any string with a comma, because the |
|||
;; numberp function below will not weed out commas |
|||
(not (string-match-p "," str)) |
|||
;; no errors from numberp function testing if a number |
|||
(ignore-errors (numberp (read str))))) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
Below is ELisp code to test two lists. One is a list of strings that |
|||
would be acceptable numbers in Emacs ELisp. The second is a list of strings |
|||
that are not valid numbers. The code tests each string in each list. |
|||
<syntaxhighlight lang="lisp"> |
|||
(setq valid-strings '("3" "0" "-0" "2." "1000" "-4" "-5." "6.2" "-8.45" "+15e2" "-15e2" "#b101100" "#o54" "#x2c" "1500.0" "#24r1k" "3")) |
|||
(setq invalid-strings '("3cat" "1,000" "5.6.7" "cat3" "def" "zero")) |
|||
(with-current-buffer (pop-to-buffer "my-test") |
|||
(erase-buffer) |
|||
(insert "Test for valid strings:\n") |
|||
(dolist (test-string valid-strings) |
|||
(let ((test-result)) |
|||
(setq test-result (string-valid-number-p test-string)) |
|||
(insert (format "%-8s - %s \n" test-string test-result)))) |
|||
(insert "\n" "\n") |
|||
(insert "Test for invalid strings:\n") |
|||
(dolist (test-string invalid-strings) |
|||
(let ((test-result)) |
|||
(setq test-result (string-valid-number-p test-string)) |
|||
(insert (format "%-5s - %s \n" test-string test-result))))) |
|||
</syntaxhighlight> |
|||
Below is the result of the tests: |
|||
<pre> |
|||
Test for valid strings: |
|||
3 - t |
|||
0 - t |
|||
-0 - t |
|||
2. - t |
|||
1000 - t |
|||
-4 - t |
|||
-5. - t |
|||
6.2 - t |
|||
-8.45 - t |
|||
+15e2 - t |
|||
-15e2 - t |
|||
#b101100 - t |
|||
#o54 - t |
|||
#x2c - t |
|||
1500.0 - t |
|||
#24r1k - t |
|||
3 - t |
|||
Test for invalid strings: |
|||
3cat - nil |
|||
1,000 - nil |
|||
5.6.7 - nil |
|||
cat3 - nil |
|||
def - nil |
|||
zero - nil |
|||
</pre> |
|||
=={{header|EMal}}== |
|||
<syntaxhighlight lang="emal"> |
|||
fun isNumeric = logic by text value |
|||
try |
|||
^|So funny: |
|||
|a) we check if it's castable to a real |
|||
|b) we obtain the real 0.0 |
|||
|c) conversion from real to int to get 0 |
|||
|d) int can be converted to logical to get ⊥ |
|||
|e) we can negate the result |
|||
|^ |
|||
return not when(value.contains("."), logic!int!(real!value * 0), logic!(int!value * 0)) |
|||
remedy |
|||
return false |
|||
end |
|||
end |
|||
fun main = int by List args |
|||
if args.length == 1 |
|||
writeLine(isNumeric(args[0])) |
|||
else |
|||
writeLine("value".padEnd(8, " ") + " " + "numeric") |
|||
for each text value in text["0o755", "thursday", "3.14", "0b1010", "-100", "0xff"] |
|||
writeLine(value.padEnd(8, " ") + " " + isNumeric(value)) |
|||
end |
|||
end |
|||
return 0 |
|||
end |
|||
exit main(Runtime.args) |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
value numeric |
|||
0o755 ⊤ |
|||
thursday ⊥ |
|||
3.14 ⊤ |
|||
0b1010 ⊤ |
|||
-100 ⊤ |
|||
0xff ⊤ |
|||
</pre> |
|||
=={{header|Erlang}}== |
|||
Erlang doesn't come with a way to say if a string represents a numeric value or not, but does come with the built-in function <tt>is_number/1</tt>, which will return true if the argument passed is either an integer or a float. Erlang also has two functions to transform a string to either a floating number or an integer, which will be used in conjunction with <tt>is_number/1</tt>. |
|||
<syntaxhighlight lang="erlang">is_numeric(L) -> |
|||
Float = (catch erlang:list_to_float(L)), |
|||
Int = (catch erlang:list_to_integer(L)), |
|||
is_number(Float) orelse is_number(Int).</syntaxhighlight> |
|||
=={{header|ERRE}}== |
|||
Short form using predeclared ERRE functions VAL and STR$. |
|||
<syntaxhighlight lang="erre"> |
|||
PROGRAM NUMERIC |
|||
PROCEDURE IS_NUMERIC(S$->ANS%) |
|||
LOCAL T1,T1$ |
|||
T1=VAL(S$) |
|||
T1$=STR$(T1) |
|||
ANS%=(T1$=S$) OR T1$=" "+S$ |
|||
END PROCEDURE |
|||
BEGIN |
|||
PRINT(CHR$(12);) |
|||
INPUT("Enter a string",S$) |
|||
IS_NUMERIC(S$->ANS%) |
|||
IF ANS% THEN PRINT("is num") ELSE PRINT("not num") |
|||
END PROGRAM |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre>Enter a string? 12.30 |
|||
is num |
|||
</pre> |
|||
=={{header|Euphoria}}== |
|||
<syntaxhighlight lang="euphoria">include get.e |
|||
function is_numeric(sequence s) |
|||
sequence val |
|||
val = value(s) |
|||
return val[1]=GET_SUCCESS and atom(val[2]) |
|||
end function</syntaxhighlight> |
|||
=={{header|F_Sharp|F#}}== |
|||
<syntaxhighlight lang="fsharp">let is_numeric a = fst (System.Double.TryParse a)</syntaxhighlight> |
|||
=={{header|Factor}}== |
|||
<syntaxhighlight lang="factor">: numeric? ( string -- ? ) string>number >boolean ;</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="java"> |
|||
class Main |
|||
{ |
|||
// function to see if str contains a number of any of built-in types |
|||
static Bool readNum (Str str) |
|||
{ |
|||
int := Int.fromStr (str, 10, false) // use base 10 |
|||
if (int != null) return true |
|||
float := Float.fromStr (str, false) |
|||
if (float != null) return true |
|||
decimal := Decimal.fromStr (str, false) |
|||
if (decimal != null) return true |
|||
return false |
|||
} |
|||
public static Void main () |
|||
{ |
|||
echo ("For '2': " + readNum ("2")) |
|||
echo ("For '-2': " + readNum ("-2")) |
|||
echo ("For '2.5': " + readNum ("2.5")) |
|||
echo ("For '2a5': " + readNum ("2a5")) |
|||
echo ("For '-2.1e5': " + readNum ("-2.1e5")) |
|||
} |
|||
} |
} |
||
</syntaxhighlight> |
|||
{{out}} |
|||
void main() { |
|||
<pre> |
|||
foreach (s; ["12", " 12\t", "hello12", "-12", "0-12", "+12", "0x10", "6b"]) { |
|||
For '2': true |
|||
writefln("isNumeric(", s, ") = ", isNumeric(s)); |
|||
For '-2': true |
|||
writefln("isInt(", s, ") = ", isInt(s)); |
|||
For '2.5': true |
|||
writefln("isInt2(", s, ") = ", isInt2(s)); |
|||
For '2a5': false |
|||
writefln("isInt3(", s, ") = ", isInt3(s)); |
|||
For '-2.1e5': true |
|||
writefln(); |
|||
</pre> |
|||
Another example inspired by the Kotlin example. Fantom does not have an enhanced for-loop (foreach) loop, but instead uses Closures as the primary mechanism of iteration. |
|||
<syntaxhighlight lang="java"> |
|||
/* gary chike 08/27/2023 */ |
|||
class Main { |
|||
static Void main() { |
|||
inputs := ["152\n", "-3.141", "Foo123", "-0", "456bar", "1.0E10"] |
|||
inputs.each |Str input| { echo("$input.trim \tis " + (isNumeric(input) ? "numeric" : "not numeric"))} |
|||
static Bool isNumeric(Str input) { |
|||
try { |
|||
input.toFloat |
|||
return true |
|||
} |
|||
catch(Err e) { |
|||
return false |
|||
} |
|||
} |
} |
||
} |
} |
||
</syntaxhighlight> |
|||
</lang> |
|||
{{out}} |
|||
<pre> |
|||
152 is numeric |
|||
-3.141 is numeric |
|||
Foo123 is not numeric |
|||
-0 is numeric |
|||
456bar is not numeric |
|||
1.0E10 is numeric |
|||
</pre> |
|||
=={{header|Forth}}== |
=={{header|Forth}}== |
||
{{works with|gforth|0.6.2}} |
{{works with|gforth|0.6.2}} |
||
<syntaxhighlight lang="forth">: 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 |
else |
||
type ." |
2swap type ." as double = " <# #s #> type |
||
then |
then |
||
else 2dup >float if |
|||
type ." as float = " f. |
|||
else |
|||
s" 1234." is-numeric \ 1234. as double = 1234 |
|||
type ." isn't numeric in base " base @ dec. |
|||
s" 1234e" is-numeric \ 1234e as float = 1234. |
|||
then then ; |
|||
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 ) |
|||
s" 1234" is-numeric \ 1234 as integer = 1234 |
|||
=={{header|Haskell}}== |
|||
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 )</syntaxhighlight> |
|||
=={{header|Fortran}}== |
|||
<syntaxhighlight lang="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</syntaxhighlight> |
|||
=={{header|Free Pascal}}== |
|||
<syntaxhighlight lang="pascal">function isNumeric(const potentialNumeric: string): boolean; |
|||
var |
|||
potentialInteger: integer; |
|||
potentialReal: real; |
|||
integerError: integer; |
|||
realError: integer; |
|||
begin |
|||
integerError := 0; |
|||
realError := 0; |
|||
// system.val attempts to convert numerical value representations. |
|||
// It accepts all notations as they are accepted by the language, |
|||
// as well as the '0x' (or '0X') prefix for hexadecimal values. |
|||
val(potentialNumeric, potentialInteger, integerError); |
|||
val(potentialNumeric, potentialReal, realError); |
|||
isNumeric := (integerError = 0) or (realError = 0); |
|||
end; |
|||
</syntaxhighlight> |
|||
The following is a more complete and compilable example. |
|||
<syntaxhighlight lang="pascal"> |
|||
program IsNumeric; |
|||
type |
|||
TDynamicArrayItem = record |
|||
StrValue: string; |
|||
end; |
|||
var |
|||
myDynamicArray: array of TDynamicArrayItem; |
|||
i: Integer; |
|||
Value: Extended; |
|||
Code: Integer; |
|||
begin |
|||
// Initialize the dynamic array with different data types |
|||
SetLength(myDynamicArray, 7); |
|||
myDynamicArray[0].StrValue := 'Hello'; |
|||
myDynamicArray[1].StrValue := '42'; |
|||
myDynamicArray[2].StrValue := '3.14159'; |
|||
myDynamicArray[3].StrValue := 'World'; |
|||
myDynamicArray[4].StrValue := '99'; |
|||
myDynamicArray[5].StrValue := '0777'; // Octal representation for 511 |
|||
myDynamicArray[6].StrValue := '$A1'; // Hexadecimal representation for 161 |
|||
// Iterate through the dynamic array and determine data type |
|||
for i := Low(myDynamicArray) to High(myDynamicArray) do |
|||
begin |
|||
Val(myDynamicArray[i].StrValue, Value, Code); |
|||
if Code = 0 then // The value 0 for Code indicates that the conversion was successful. |
|||
Writeln('Element ', i, ': Numeric Value ', Chr(9),' - ', Value) // Chr(9) = tab |
|||
else |
|||
Writeln('Element ', i, ': Non-Numeric Value ', Chr(9), ' - ', myDynamicArray[i].StrValue); |
|||
end; |
|||
end. |
|||
{ Val converts the value represented in the string 'StrValue' to a numerical value or an enumerated value, and stores this value in the variable 'Value', which can be of type Longint, Real and Byte or any enumerated type. If the conversion isn't successful, then the parameter 'Code' contains the index of the character in 'StrValue' which prevented the conversion. } |
|||
</syntaxhighlight> |
|||
{{out}}: |
|||
<pre> |
|||
Free Pascal Compiler version 3.2.2 [2021/10/28] for x86_64 |
|||
Copyright (c) 1993-2021 by Florian Klaempfl and others |
|||
Target OS: Darwin for x86_64 |
|||
Compiling arrVariantIsNumeric.pas |
|||
Assembling arrvariantisnumeric |
|||
Linking arrVariantIsNumeric |
|||
37 lines compiled, 0.3 sec |
|||
Element 0: Non-Numeric Value - Hello |
|||
Element 1: Numeric Value - 4.20000000000000000000E+0001 |
|||
Element 2: Numeric Value - 3.14158999999999999993E+0000 |
|||
Element 3: Non-Numeric Value - World |
|||
Element 4: Numeric Value - 9.90000000000000000000E+0001 |
|||
Element 5: Numeric Value - 7.77000000000000000000E+0002 |
|||
Element 6: Non-Numeric Value - $A1 |
|||
</pre> |
|||
=={{header|FreeBASIC}}== |
|||
FreeBASIC has a built-in Val() function which converts numeric strings to doubles. However, it is not ideal for the present task |
|||
since it will try to convert as much of the string as it can (so "123xyz" would convert to 123) and return 0 if a conversion on |
|||
this basis is not possible (i.e. "xyz" would return 0). |
|||
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. |
|||
<syntaxhighlight lang="freebasic">' FB 1.05.0 Win64 |
|||
Dim Shared symbols(0 To 15) As UByte |
|||
For i As Integer = 48 to 57 |
|||
symbols(i - 48) = i |
|||
Next |
|||
For i As Integer = 97 to 102 |
|||
symbols(i - 87) = i |
|||
Next |
|||
Const plus As UByte = 43 |
|||
Const minus As Ubyte = 45 |
|||
Const dot As UByte = 46 |
|||
Function isNumeric(s As Const String, base_ As Integer = 10) As Boolean |
|||
If s = "" OrElse s = "." OrElse s = "+" OrElse s = "-" Then Return False |
|||
Err = 0 |
|||
If base_ < 2 OrElse base_ > 16 Then |
|||
Err = 1000 |
|||
Return False |
|||
End If |
|||
Dim t As String = LCase(s) |
|||
If (t[0] = plus) OrElse (t[0] = minus) Then |
|||
t = Mid(t, 2) |
|||
End If |
|||
If Left(t, 2) = "&h" Then |
|||
If base_ <> 16 Then Return False |
|||
t = Mid(t, 3) |
|||
End if |
|||
If Left(t, 2) = "&o" Then |
|||
If base_ <> 8 Then Return False |
|||
t = Mid(t, 3) |
|||
End if |
|||
If Left(t, 2) = "&b" Then |
|||
If base_ <> 2 Then Return False |
|||
t = Mid(t, 3) |
|||
End if |
|||
If Len(t) = 0 Then Return False |
|||
Dim As Boolean isValid, hasDot = false |
|||
For i As Integer = 0 To Len(t) - 1 |
|||
isValid = False |
|||
For j As Integer = 0 To base_ - 1 |
|||
If t[i] = symbols(j) Then |
|||
isValid = True |
|||
Exit For |
|||
End If |
|||
If t[i] = dot Then |
|||
If CInt(Not hasDot) AndAlso (base_ = 10) Then |
|||
hasDot = True |
|||
IsValid = True |
|||
Exit For |
|||
End If |
|||
Return False ' either more than one dot or not base 10 |
|||
End If |
|||
Next j |
|||
If Not isValid Then Return False |
|||
Next i |
|||
Return True |
|||
End Function |
|||
Dim s As String |
|||
s = "1234.056789" |
|||
Print s, " (base 10) => "; isNumeric(s) |
|||
s = "1234.56" |
|||
Print s, " (base 7) => "; isNumeric(s, 7) |
|||
s = "021101" |
|||
Print s, " (base 2) => "; isNumeric(s, 2) |
|||
s = "Dog" |
|||
Print s, " (base 16) => "; isNumeric(s, 16) |
|||
s = "Bad125" |
|||
Print s, " (base 16) => "; isNumeric(s, 16) |
|||
s = "-0177" |
|||
Print s, " (base 8) => "; isNumeric(s, 8) |
|||
s = "+123abcd.ef" |
|||
Print s, " (base 16) => "; isNumeric(s, 8) |
|||
s = "54321" |
|||
Print s, " (base 6) => "; isNumeric(s, 6) |
|||
s = "123xyz" |
|||
Print s, " (base 10) => "; isNumeric(s) |
|||
s = "xyz" |
|||
Print s, " (base 10) => "; isNumeric(s) |
|||
Print |
|||
Print "Press any key to quit" |
|||
Sleep</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1234.056789 (base 10) => true |
|||
1234.56 (base 7) => false |
|||
021101 (base 2) => false |
|||
Dog (base 16) => false |
|||
Bad125 (base 16) => true |
|||
-0177 (base 8) => true |
|||
+123abcd.ef (base 16) => false |
|||
54321 (base 6) => true |
|||
123xyz (base 10) => false |
|||
xyz (base 10) => false |
|||
</pre> |
|||
=={{header|FutureBasic}}== |
|||
<syntaxhighlight lang="futurebasic">include "NSLog.incl" |
|||
local fn StringIsNumeric( string as CFStringRef ) as BOOL |
|||
BOOL flag = NO |
|||
ScannerRef scanner = fn ScannerWithString( string ) |
|||
if ( fn ScannerScanFloat( scanner, NULL ) ) |
|||
flag = fn ScannerIsAtEnd( scanner ) |
|||
end if |
|||
end fn = flag |
|||
NSLog(@"%d",fn StringIsNumeric( @"1.23" )) |
|||
NSLog(@"%d",fn StringIsNumeric( @"-123.4e5" )) |
|||
NSLog(@"%d",fn StringIsNumeric( @"alpha" )) |
|||
HandleEvents</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1 |
|||
1 |
|||
0 |
|||
</pre> |
|||
=={{header|Gambas}}== |
|||
<syntaxhighlight lang="gambas">Public Sub Form_Open() |
|||
Dim sAnswer, sString As String |
|||
sString = Trim(InputBox("Enter as string", "String or Numeric")) |
|||
If IsNumber(sString) Then sAnswer = "'" & sString & "' is numeric" Else sAnswer = "'" & sString & "' is a string" |
|||
Print sAnswer |
|||
End</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
'Charlie' is a string |
|||
'-00.256666' is numeric |
|||
</pre> |
|||
=={{header|Go}}== |
|||
This uses a library function to meet the task's requirements: |
|||
<syntaxhighlight lang="go">package main |
|||
import ( |
|||
"fmt" |
|||
"strconv" |
|||
) |
|||
func isNumeric(s string) bool { |
|||
_, err := strconv.ParseFloat(s, 64) |
|||
return err == nil |
|||
} |
|||
func main() { |
|||
fmt.Println("Are these strings numeric?") |
|||
strings := []string{"1", "3.14", "-100", "1e2", "NaN", "rose"} |
|||
for _, s := range strings { |
|||
fmt.Printf(" %4s -> %t\n", s, isNumeric(s)) |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Are these strings numeric? |
|||
1 -> true |
|||
3.14 -> true |
|||
-100 -> true |
|||
1e2 -> true |
|||
NaN -> true |
|||
rose -> false |
|||
</pre> |
|||
This uses both a library function and a custom one but only checks for integerness: |
|||
<syntaxhighlight lang="go">package main |
|||
import ( |
|||
"fmt" |
|||
"strconv" |
|||
"unicode" |
|||
) |
|||
func isInt(s string) bool { |
|||
for _, c := range s { |
|||
if !unicode.IsDigit(c) { |
|||
return false |
|||
} |
|||
} |
|||
return true |
|||
} |
|||
func main() { |
|||
fmt.Println("Are these strings integers?") |
|||
v := "1" |
|||
b := false |
|||
if _, err := strconv.Atoi(v); err == nil { |
|||
b = true |
|||
} |
|||
fmt.Printf(" %3s -> %t\n", v, b) |
|||
i := "one" |
|||
fmt.Printf(" %3s -> %t\n", i, isInt(i)) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Are these strings integers? |
|||
1 -> true |
|||
one -> false |
|||
</pre> |
|||
=={{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. |
|||
<syntaxhighlight lang="groovy">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() |
|||
}</syntaxhighlight> |
|||
Test Program: |
|||
<syntaxhighlight lang="groovy">println isNumeric('1') |
|||
println isNumeric('-.555') |
|||
println isNumeric('1,000,000') |
|||
println isNumeric(' 1 1 1 1 ') |
|||
println isNumeric('abcdef')</syntaxhighlight> |
|||
{{out}} |
|||
<pre>true |
|||
true |
|||
true |
|||
false |
|||
false</pre> |
|||
=={{header|Haskell}}== |
|||
This function is not particularly useful in a statically typed language. Instead, one would just attempt to convert the string |
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. |
to the desired type with ''read'' or ''reads'', and handle parsing failure appropriately. |
||
Line 259: | Line 2,666: | ||
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): |
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): |
||
<syntaxhighlight lang="haskell">isInteger s = case reads s :: [(Integer, String)] of |
|||
<lang haskell> |
|||
isInteger s = case reads s :: [(Integer, String)] of |
|||
[(_, "")] -> True |
[(_, "")] -> True |
||
_ -> False |
_ -> False |
||
Line 269: | Line 2,675: | ||
isNumeric :: String -> Bool |
isNumeric :: String -> Bool |
||
isNumeric s = isInteger s || isDouble s |
isNumeric s = isInteger s || isDouble s</syntaxhighlight> |
||
</lang> |
|||
One can easily add ''isRational'', ''isComplex'' etc. following the same pattern. |
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: |
|||
<syntaxhighlight lang="haskell">areDigits = all isDigit |
|||
isDigit selects ASCII digits i.e. '0'..'9' |
|||
isOctDigit selects '0'..'7' |
|||
isHexDigit selects '0'..'9','A'..'F','a'..'f'</syntaxhighlight> |
|||
so read s::Int (for instance) could be reliably used if string s passed these tests. |
|||
=={{header|Haxe}}== |
|||
Haxe has a built-in function that will convert a string to an integer, so we can use that to determine if the string is numeric or not. <syntaxhighlight lang="actionscript"> |
|||
static function isNumeric(n:String):Bool |
|||
{ |
|||
if (Std.parseInt(n) != null) //Std.parseInt converts a string to an int |
|||
{ |
|||
return true; //as long as it results in an integer, the function will return true |
|||
} |
|||
else |
|||
{ |
|||
return false; |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|HicEst}}== |
|||
<syntaxhighlight lang="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</syntaxhighlight> |
|||
=={{header|i}}== |
|||
<syntaxhighlight lang="i">concept numeric(n) { |
|||
number(n) |
|||
errors { |
|||
print(n, " is not numeric!") |
|||
return |
|||
} |
|||
print(n, " is numeric :)") |
|||
} |
|||
software { |
|||
numeric("1200") |
|||
numeric("3.14") |
|||
numeric("3/4") |
|||
numeric("abcdefg") |
|||
numeric("1234test") |
|||
}</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="icon"> |
|||
write(image(x), if numeric(x) then " is numeric." else " is not numeric") |
|||
</syntaxhighlight> |
|||
=={{header|IDL}}== |
=={{header|IDL}}== |
||
<syntaxhighlight lang="idl">function isnumeric,input |
|||
on_ioerror, false |
|||
test = double(input) |
|||
return, 1 |
|||
false: return, 0 |
|||
end</syntaxhighlight> |
|||
end |
|||
Could be called like this: |
Could be called like this: |
||
<syntaxhighlight lang="idl">if isnumeric('-123.45e-2') then print, 'yes' else print, 'no' |
|||
; ==> yes |
|||
if isnumeric('picklejuice') then print, 'yes' else print, 'no' |
|||
; ==> no</syntaxhighlight> |
|||
=={{header|Insitux}}== |
|||
Non-null and non-false values are truthy in Insitux. The operation <b>to-num</b> returns null if it is unable to parse its string parameter, else the parsed number. The operation <b>bool</b> is unnecessary in most situations, but is composed with <b>to-num</b> here to satisfy the task specification. |
|||
<syntaxhighlight lang="insitux">> (var numeric? (comp to-num bool)) |
|||
(comp to-num bool) |
|||
> (numeric? "123") |
|||
true |
|||
> (numeric? "0x25") |
|||
true |
|||
> (numeric? "0b0101") |
|||
true |
|||
> (numeric? "hello") |
|||
false |
|||
> (numeric? "123x456") |
|||
false</syntaxhighlight> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
<syntaxhighlight lang="j">isNumeric=: _ ~: _ ". ] |
|||
isNumericScalar=: 1 -: isNumeric |
|||
TXT=: ,&' a scalar numeric value.' &.> ' is not';' represents' |
|||
sayIsNumericScalar=: , TXT {::~ isNumericScalar</syntaxhighlight> |
|||
Examples of use: |
Examples of use: |
||
isNumeric '152' |
<syntaxhighlight lang="j"> isNumeric '152' |
||
1 |
|||
isNumeric '152 -3.1415926 Foo123' |
|||
1 1 0 |
|||
isNumeric '42 foo42 4.2e1 4200e-2 126r3 16b2a 42foo' |
|||
isNumericScalar '152 -3.1415926 Foo123' |
|||
1 0 1 1 1 1 0 |
|||
0 |
|||
isNumericScalar '152 -3.1415926 Foo123' |
|||
0 |
|||
-3.1415926 represents a scalar numeric value. |
|||
sayIsNumericScalar '-3.1415926' |
|||
-3.1415926 represents a scalar numeric value.</syntaxhighlight> |
|||
=={{header|Java}}== |
=={{header|Java}}== |
||
Typically, you would use the 'parse' methods from either the ''Integer'', ''Long'', ''Float'', or ''Double'' class, <br />which will throw a ''NumberFormatException'' for ill-formed values.<br /> |
|||
For example |
|||
<syntaxhighlight lang="java"> |
|||
Integer.parseInt("12345") |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="java"> |
|||
Float.parseFloat("123.456") |
|||
</syntaxhighlight> |
|||
The performance mark is somewhat negligible between a try-block and custom methods. |
|||
<syntaxhighlight lang="java"> |
|||
public static void main(String[] args) { |
|||
String value; |
|||
value = "1234567"; |
|||
System.out.printf("%-10s %b%n", value, isInteger(value)); |
|||
value = "12345abc"; |
|||
System.out.printf("%-10s %b%n", value, isInteger(value)); |
|||
value = "-123.456"; |
|||
System.out.printf("%-10s %b%n", value, isFloatingPoint(value)); |
|||
value = "-.456"; |
|||
System.out.printf("%-10s %b%n", value, isFloatingPoint(value)); |
|||
value = "123."; |
|||
System.out.printf("%-10s %b%n", value, isFloatingPoint(value)); |
|||
value = "123.abc"; |
|||
System.out.printf("%-10s %b%n", value, isFloatingPoint(value)); |
|||
} |
|||
static boolean isInteger(String string) { |
|||
String digits = "0123456789"; |
|||
for (char character : string.toCharArray()) { |
|||
if (!digits.contains(String.valueOf(character))) |
|||
return false; |
|||
} |
|||
return true; |
|||
} |
|||
static boolean isFloatingPoint(String string) { |
|||
/* at least one decimal-point */ |
|||
int indexOf = string.indexOf('.'); |
|||
if (indexOf == -1) |
|||
return false; |
|||
/* assure only 1 decimal-point */ |
|||
if (indexOf != string.lastIndexOf('.')) |
|||
return false; |
|||
if (string.charAt(0) == '-' || string.charAt(0) == '+') { |
|||
string = string.substring(1); |
|||
indexOf--; |
|||
} |
|||
String integer = string.substring(0, indexOf); |
|||
if (!integer.isEmpty()) { |
|||
if (!isInteger(integer)) |
|||
return false; |
|||
} |
|||
String decimal = string.substring(indexOf + 1); |
|||
if (!decimal.isEmpty()) |
|||
return isInteger(decimal); |
|||
return true; |
|||
} |
|||
</syntaxhighlight> |
|||
<pre> |
|||
1234567 true |
|||
12345abc false |
|||
-123.456 true |
|||
-.456 true |
|||
123. true |
|||
123.abc false |
|||
</pre> |
|||
<br /> |
|||
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. |
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. |
||
<syntaxhighlight lang="java">public boolean isNumeric(String input) { |
|||
<lang java> |
|||
public boolean isNumeric(String input) { |
|||
try { |
try { |
||
Integer.parseInt(input); |
Integer.parseInt(input); |
||
Line 316: | Line 2,888: | ||
return false; |
return false; |
||
} |
} |
||
}</syntaxhighlight> |
|||
} |
|||
</lang> |
|||
Alternative 1 : Check that each character in the string is number. Note that this will only works for integers. |
Alternative 1 : Check that each character in the string is number. Note that this will only works for integers. |
||
<syntaxhighlight lang="java">private static final boolean isNumeric(final String s) { |
|||
<lang java> |
|||
if (s == null || s.isEmpty()) return false; |
|||
private static final boolean isNumeric(final String s) { |
|||
for (int x = 0; x < s.length(); x++) { |
for (int x = 0; x < s.length(); x++) { |
||
final char c = s.charAt(x); |
final char c = s.charAt(x); |
||
Line 330: | Line 2,901: | ||
} |
} |
||
return true; // valid |
return true; // valid |
||
}</syntaxhighlight> |
|||
} |
|||
</lang> |
|||
Alternative 2 : use a regular expression (a more elegant solution). |
Alternative 2 : use a regular expression (a more elegant solution). |
||
<syntaxhighlight lang="java">public static boolean isNumeric(String inputData) { |
|||
<lang java> |
|||
return inputData.matches("[-+]?\\d+(\\.\\d+)?"); |
|||
public static boolean isNumeric(String inputData) { |
|||
}</syntaxhighlight> |
|||
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. |
|||
</lang> |
|||
<syntaxhighlight lang="java">public static boolean isNumeric(String inputData) { |
|||
NumberFormat formatter = NumberFormat.getInstance(); |
|||
ParsePosition pos = new ParsePosition(0); |
|||
formatter.parse(inputData, pos); |
|||
return inputData.length() == pos.getIndex(); |
|||
}</syntaxhighlight> |
|||
Alternative 4 : use the java.util.Scanner object. Very useful if you have to scan multiple entries. |
|||
<syntaxhighlight lang="java">public static boolean isNumeric(String inputData) { |
|||
Scanner sc = new Scanner(inputData); |
|||
return sc.hasNextInt(); |
|||
}</syntaxhighlight> |
|||
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}}== |
=={{header|JavaScript}}== |
||
A far better validator can be found on StackOverflow[http://stackoverflow.com/questions/18082/validate-numbers-in-javascript-isnumeric] |
|||
<lang javascript> |
|||
<syntaxhighlight lang="javascript">function isNumeric(n) { |
|||
string value = "123.45e7"; |
|||
return !isNaN(parseFloat(n)) && isFinite(n); |
|||
if (isFinite(value)) |
|||
{ |
|||
// do something |
|||
} |
} |
||
var value = "123.45e7"; // Assign string literal to value |
|||
//Or, in web browser in URL box: |
|||
if (isNumeric(value)) { |
|||
// javascript:value="123.45e4"; if(isFinite(value)) {alert('numeric')} else {alert('non-numeric')} |
|||
// value is a number |
|||
</lang> |
|||
} |
|||
//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')} |
|||
</syntaxhighlight> |
|||
=={{header|jq}}== |
|||
'''Works with jq, the C implementation of jq''' |
|||
'''Works with gojq, the Go implementation of jq''' |
|||
'''Works with jaq, the Rust implementation of jq''' |
|||
The simplest way to test if a string can be parsed as a number is:<syntaxhighlight lang="jq">try tonumber catch false</syntaxhighlight> |
|||
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: |
|||
<syntaxhighlight lang="jq">def is_numeric: true and try tonumber catch false;</syntaxhighlight> |
|||
=={{header|Julia}}== |
|||
The function <tt>isnumber</tt> tests for strings that parse directly to numbers. This test excludes symbols, such as π 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. |
|||
<syntaxhighlight lang="julia">using Printf |
|||
isnumber(s::AbstractString) = tryparse(Float64, s) isa Number |
|||
tests = ["1", "-121", "one", "pi", "1 + 1", "NaN", "1234567890123456789", "1234567890123456789123456789", |
|||
"1234567890123456789123456789.0", "1.3", "1.4e10", "Inf", "1//2", "1.0 + 1.0im"] |
|||
for t in tests |
|||
fl = isnumber(t) ? "is" : "is not" |
|||
@printf("%35s %s a direct numeric literal.\n", t, fl) |
|||
end</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
1 is a direct numeric literal. |
|||
-121 is a direct numeric literal. |
|||
one is not a direct numeric literal. |
|||
pi is not a direct numeric literal. |
|||
1 + 1 is not a direct numeric literal. |
|||
NaN is a direct numeric literal. |
|||
1234567890123456789 is a direct numeric literal. |
|||
1234567890123456789123456789 is a direct numeric literal. |
|||
1234567890123456789123456789.0 is a direct numeric literal. |
|||
1.3 is a direct numeric literal. |
|||
1.4e10 is a direct numeric literal. |
|||
Inf is a direct numeric literal. |
|||
1//2 is not a direct numeric literal. |
|||
1.0 + 1.0im is not a direct numeric literal. |
|||
</pre> |
|||
=={{header|Kotlin}}== |
|||
<syntaxhighlight lang="scala">// version 1.1 |
|||
fun isNumeric(input: String): Boolean = |
|||
try { |
|||
input.toDouble() |
|||
true |
|||
} catch(e: NumberFormatException) { |
|||
false |
|||
} |
|||
fun main(args: Array<String>) { |
|||
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"}") |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
152 is numeric |
|||
-3.1415926 is numeric |
|||
Foo123 is not numeric |
|||
-0 is numeric |
|||
456bar is not numeric |
|||
1.0E10 is numeric |
|||
</pre> |
|||
=={{header|LabVIEW}}== |
|||
{{VI solution|LabVIEW_Determine_if_a_string_is_numeric.png}} |
|||
=={{header|Lasso}}== |
|||
{{works with|Lasso|8 & 9 }} |
|||
<syntaxhighlight lang="lasso">local(str='12345') |
|||
string_isNumeric(#str) // true</syntaxhighlight> |
|||
{{works with|Lasso|9}} |
|||
<syntaxhighlight lang="lasso">'12345'->isdigit // true |
|||
'1X34Q'->isdigit // false</syntaxhighlight> |
|||
=={{header|Liberty BASIC}}== |
|||
<syntaxhighlight lang="lb"> |
|||
DATA "PI", "0123", "-0123", "12.30", "-12.30", "123!", "0" |
|||
DATA "0.0", ".123", "-.123", "12E3", "12E-3", "12+3", "end" |
|||
while n$ <> "end" |
|||
read n$ |
|||
print n$, IsNumber(n$) |
|||
wend |
|||
end |
|||
function IsNumber(string$) |
|||
on error goto [NotNumber] |
|||
string$ = trim$(string$) |
|||
'check for float overflow |
|||
n = val(string$) |
|||
'assume it is number and try to prove wrong |
|||
IsNumber = 1 |
|||
for i = 1 to len(string$) |
|||
select case mid$(string$, i, 1) |
|||
case "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" |
|||
HasNumeric = 1 'to check if there are any digits |
|||
case "e", "E" |
|||
'"e" must not occur more than once |
|||
'must not occur before digits |
|||
if HasE > 0 or HasNumeric = 0 then |
|||
IsNumber = 0 |
|||
exit for |
|||
end if |
|||
HasE = i 'store position of "e" |
|||
HasNumeric = 0 'needs numbers after "e" |
|||
case "-", "+" |
|||
'must be either first character or immediately after "e" |
|||
'(HasE = 0 if no occurrences yet) |
|||
if HasE <> i-1 then |
|||
IsNumber = 0 |
|||
exit for |
|||
end if |
|||
case "." |
|||
'must not have previous points and must not come after "e" |
|||
if HasE <> 0 or HasPoint <> 0 then |
|||
IsNumber = 0 |
|||
exit for |
|||
end if |
|||
HasPoint = 1 |
|||
case else |
|||
'no other characters allowed |
|||
IsNumber = 0 |
|||
exit for |
|||
end select |
|||
next i |
|||
'must have digits |
|||
if HasNumeric = 0 then IsNumber = 0 |
|||
[NotNumber] |
|||
end function |
|||
</syntaxhighlight> |
|||
=={{header|Lisaac}}== |
|||
<syntaxhighlight lang="lisaac"> |
|||
"123457".is_integer.println; |
|||
// write TRUE on stdin |
|||
</syntaxhighlight> |
|||
=={{header|Logo}}== |
=={{header|Logo}}== |
||
<syntaxhighlight lang="logo">show number? "-1.23 ; true</syntaxhighlight> |
|||
=={{header|Lua}}== |
|||
This will also accept strings like "0xFF" or "314.16e-2" as numbers. |
|||
<syntaxhighlight lang="lua">if tonumber(a) ~= nil then |
|||
--it's a number |
|||
end; |
|||
</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
\\ version 2 |
|||
Module Checkit { |
|||
function global isNumber(a$, de$=".") { |
|||
=false=true ' return boolean |
|||
if de$="" then de$=str$(.1,".") ' get current decimal point character |
|||
a$=trim$(ucase$(a$)) |
|||
m=len(a$) |
|||
if m=0 then exit |
|||
c$=filter$(a$,"0123456789") |
|||
if c$ = "" then { |
|||
=true |
|||
} else.if m>1 then { |
|||
\ may have -+ and , |
|||
if m=2 then { |
|||
if not c$~"[-+\"+de$+"]" then break |
|||
} else { |
|||
if left$(c$,1 ) ~"[+-]" then c$=mid$(c$, 2) |
|||
if not (c$=de$ or c$=de$+"E" or c$ ~ de$+"E[+-]") then break |
|||
if c$ ~ de$+"E[+-]" then if not (instr(a$,"E+")>0 or instr(a$,"E-")>0) then break |
|||
} |
|||
if de$<>"." then a$=replace$(de$, ".", a$, 1,1) |
|||
try {inline "a="+a$+"=="+a$} |
|||
if valid(a) then =a = true=true ' return boolean |
|||
} |
|||
} |
|||
Print isNumber("+1"), isnumber("-1"), isNumber("1+")=false, isnumber("1-")=false |
|||
Print isNumber(",1",","), isnumber("1,",","), isNumber(",0",","), isnumber("0,", ",") |
|||
Print isNumber(".1"), isnumber("1."), isNumber(".0"), isnumber("0.") |
|||
Print isNumber("+.1"), isnumber("-1."), isNumber(".12e+232"), isnumber("0.122e10") |
|||
Print isNumber("+.1a")=false, isnumber("asasa1212")=false, isNumber("1.2e43+23")=false, isnumber("0.122e10") |
|||
Print isNumber("1221.211.1221")=false, isnumber("1221e1212")=false, isNumber("1.2e4323")=false, isnumber("-.122e-10") |
|||
} |
|||
Checkit |
|||
</syntaxhighlight> |
|||
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. |
|||
<syntaxhighlight lang="m2000 interpreter"> |
|||
Function IsNumeric(a$) { |
|||
def m |
|||
=val(false->boolean) |
|||
Try { |
|||
if islet then { |
|||
z=val(a$,letter$, m) |
|||
} else.if isnum then { |
|||
z=val(a$,number, m) |
|||
} else z=val(a$,"", m) |
|||
=m>len(a$) |
|||
} |
|||
} |
|||
Function IsIntegerNumeric(a$) { |
|||
def m |
|||
=val(false->boolean) |
|||
Try { |
|||
z=val(a$,"Int", m) |
|||
=m>len(a$) |
|||
} |
|||
} |
|||
Locale 1033 ' to use . as decimal, else we have to place 1033 or "." as second parameter |
|||
Print isNumeric("+1"), isNumeric("-1"), isNumeric("1+")=false, isNumeric("1-")=false |
|||
Print isNumeric(",1",","), isNumeric("1,",","), isNumeric(",0",","), isNumeric("0,", ",") |
|||
Print isNumeric(".1"), isNumeric("1."), isNumeric(".0"), isNumeric("0.") |
|||
Print isNumeric("+.1"), isNumeric("-1."), isNumeric(".12e+232"), isNumeric("0.122e10") |
|||
Print isNumeric("+.1a")=false, isNumeric("asasa1212")=false, isNumeric("1.2e43+23")=false, isNumeric("0.122e10") |
|||
Print isNumeric("1221.211.1221")=false, isNumeric("1221e1212")=false, isNumeric("1.2e4323")=false, isNumeric("-.122e-10") |
|||
</syntaxhighlight> |
|||
=={{header|Maple}}== |
|||
<syntaxhighlight lang="maple">isNumeric := proc(s) |
|||
try |
|||
if type(parse(s), numeric) then |
|||
printf("The string is numeric."): |
|||
else |
|||
printf("The string is not numeric."): |
|||
end if: |
|||
catch: |
|||
printf("The string is not numeric."): |
|||
end try: |
|||
end proc:</syntaxhighlight> |
|||
=={{header|Mathematica}} / {{header|Wolfram Language}}== |
|||
<syntaxhighlight lang="mathematica">NumberQ[ToExpression["02553352000242"]]</syntaxhighlight> |
|||
=={{header|MATLAB}}== |
|||
<syntaxhighlight lang="matlab"> |
|||
function r = isnum(a) |
|||
r = ~isnan(str2double(a)) |
|||
end |
|||
% tests |
|||
disp(isnum(123)) % 1 |
|||
disp(isnum("123")) % 1 |
|||
disp(isnum("foo123")) % 0 |
|||
disp(isnum("123bar")) % 0 |
|||
disp(isnum("3.1415")) % 1 |
|||
</syntaxhighlight> |
|||
=={{header|Maxima}}== |
|||
<syntaxhighlight lang="maxima">numberp(parse_string("170141183460469231731687303715884105727"));</syntaxhighlight> |
|||
=={{header|MAXScript}}== |
=={{header|MAXScript}}== |
||
<syntaxhighlight lang="maxscript">fn isNumeric str = |
|||
( |
|||
try |
|||
( |
|||
(str as integer) != undefined |
|||
) |
|||
catch(false) |
|||
) |
|||
isNumeric "123"</syntaxhighlight> |
|||
=={{header|min}}== |
|||
{{works with|min|0.19.3}} |
|||
<syntaxhighlight lang="min">( |
|||
dup (((int integer?) (pop false)) try) dip |
|||
((float float?) (pop false)) try or |
|||
) :numeric?</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="miniscript">isNumeric = function(s) |
|||
return s == "0" or s == "-0" or val(s) != 0 |
|||
end function |
|||
print isNumeric("0") |
|||
print isNumeric("42") |
|||
print isNumeric("-3.14157") |
|||
print isNumeric("5@*#!") |
|||
print isNumeric("spam")</syntaxhighlight> |
|||
{{out}} |
|||
<pre>1 |
|||
1 |
|||
1 |
|||
1 |
|||
0</pre> |
|||
=={{header|MIPS Assembly}}== |
|||
<syntaxhighlight lang="mips"> |
|||
# $a0 char val |
|||
# $a1 address pointer |
|||
# $a2 PERIOD_HIT_FLAG |
|||
# $a3 HAS_DIGITS_FLAG |
|||
.data |
|||
### CHANGE THIS STRING TO TEST DIFFERENT ONES... ### |
|||
string: .asciiz "-.1236" |
|||
s_false: .asciiz "False" |
|||
s_true: .asciiz "True" |
|||
.text |
|||
main: |
|||
set_up: #test for 0th char == 45 or 46 or 48...57 |
|||
la $a1,string |
|||
lb $a0,($a1) |
|||
beq $a0,45,loop # == '-' |
|||
beq $a0,46,loop # == '.' |
|||
blt $a0,48,exit_false # isn't below the ascii range for chars '0'...'9' |
|||
bgt $a0,57,exit_false # isn't above the ascii range for chars '0'...'9' |
|||
loop: |
|||
addi $a1,$a1,1 |
|||
lb $a0,($a1) |
|||
beqz $a0,exit_true # test for \0 null char |
|||
beq $a0,46,period_test #test for a duplicate period |
|||
blt $a0,48,exit_false #test for |
|||
bgt $a0,57,exit_false |
|||
la $a3,1 #set the HAS_DIGITS flag. This line is only reached because the |
|||
# tests for period and - both jump back to start. |
|||
j loop |
|||
exit_true: |
|||
beqz $a3,exit_false |
|||
la $a0,s_true |
|||
la $v0,4 |
|||
syscall |
|||
li $v0,10 |
|||
syscall |
|||
exit_false: |
|||
la $a0,s_false |
|||
la $v0,4 |
|||
syscall |
|||
li $v0,10 |
|||
syscall |
|||
period_test: |
|||
beq $a2,1,exit_false |
|||
li $a2,1 |
|||
j loop |
|||
</syntaxhighlight> |
|||
=={{header|Mirah}}== |
|||
<syntaxhighlight lang="mirah">import java.text.NumberFormat |
|||
import java.text.ParsePosition |
|||
import java.util.Scanner |
|||
# this first example relies on catching an exception, |
|||
# which is bad style and poorly performing in Java |
|||
def is_numeric?(s:string) |
|||
begin |
|||
Double.parseDouble(s) |
|||
return true |
|||
rescue |
|||
return false |
|||
end |
|||
end |
|||
puts '123 is numeric' if is_numeric?('123') |
|||
puts '-123 is numeric' if is_numeric?('-123') |
|||
puts '123.1 is numeric' if is_numeric?('123.1') |
|||
puts 'nil is not numeric' unless is_numeric?(nil) |
|||
puts "'' is not numeric" unless is_numeric?('') |
|||
puts 'abc is not numeric' unless is_numeric?('abc') |
|||
puts '123- is not numeric' unless is_numeric?('123-') |
|||
puts '1.2.3 is not numeric' unless is_numeric?('1.2.3') |
|||
# check every element of the string |
|||
def is_numeric2?(s: string) |
|||
if (s == nil || s.isEmpty()) |
|||
return false |
|||
end |
|||
if (!s.startsWith('-')) |
|||
if s.contains('-') |
|||
return false |
|||
end |
|||
end |
|||
0.upto(s.length()-1) do |x| |
|||
c = s.charAt(x) |
|||
if ((x == 0) && (c == '-'.charAt(0))) |
|||
# negative number |
|||
elsif (c == '.'.charAt(0)) |
|||
if (s.indexOf('.', x) > -1) |
|||
return false # more than one period |
|||
end |
|||
elsif (!Character.isDigit(c)) |
|||
return false |
|||
end |
|||
end |
|||
true |
|||
end |
|||
puts '123 is numeric' if is_numeric2?('123') |
|||
puts '-123 is numeric' if is_numeric2?('-123') |
|||
puts '123.1 is numeric' if is_numeric2?('123.1') |
|||
puts 'nil is not numeric' unless is_numeric2?(nil) |
|||
puts "'' is not numeric" unless is_numeric2?('') |
|||
puts 'abc is not numeric' unless is_numeric2?('abc') |
|||
puts '123- is not numeric' unless is_numeric2?('123-') |
|||
puts '1.2.3 is not numeric' unless is_numeric2?('1.2.3') |
|||
# use a regular expression |
|||
def is_numeric3?(s:string) |
|||
s == nil || s.matches("[-+]?\\d+(\\.\\d+)?") |
|||
end |
|||
puts '123 is numeric' if is_numeric3?('123') |
|||
puts '-123 is numeric' if is_numeric3?('-123') |
|||
puts '123.1 is numeric' if is_numeric3?('123.1') |
|||
puts 'nil is not numeric' unless is_numeric3?(nil) |
|||
puts "'' is not numeric" unless is_numeric3?('') |
|||
puts 'abc is not numeric' unless is_numeric3?('abc') |
|||
puts '123- is not numeric' unless is_numeric3?('123-') |
|||
puts '1.2.3 is not numeric' unless is_numeric3?('1.2.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. |
|||
def is_numeric4?(s:string) |
|||
return false if s == nil |
|||
formatter = NumberFormat.getInstance() |
|||
pos = ParsePosition.new(0) |
|||
formatter.parse(s, pos) |
|||
s.length() == pos.getIndex() |
|||
end |
|||
puts '123 is numeric' if is_numeric4?('123') |
|||
puts '-123 is numeric' if is_numeric4?('-123') |
|||
puts '123.1 is numeric' if is_numeric4?('123.1') |
|||
puts 'nil is not numeric' unless is_numeric4?(nil) |
|||
puts "'' is not numeric" unless is_numeric4?('') |
|||
puts 'abc is not numeric' unless is_numeric4?('abc') |
|||
puts '123- is not numeric' unless is_numeric4?('123-') |
|||
puts '1.2.3 is not numeric' unless is_numeric4?('1.2.3') |
|||
# use the java.util.Scanner object. Very useful if you have to |
|||
# scan multiple entries. 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). |
|||
def is_numeric5?(s:string) |
|||
return false if s == nil |
|||
Scanner sc = Scanner.new(s) |
|||
sc.hasNextDouble() |
|||
end |
|||
puts '123 is numeric' if is_numeric5?('123') |
|||
puts '-123 is numeric' if is_numeric5?('-123') |
|||
puts '123.1 is numeric' if is_numeric5?('123.1') |
|||
puts 'nil is not numeric' unless is_numeric5?(nil) |
|||
puts "'' is not numeric" unless is_numeric5?('') |
|||
puts 'abc is not numeric' unless is_numeric5?('abc') |
|||
puts '123- is not numeric' unless is_numeric5?('123-') |
|||
puts '1.2.3 is not numeric' unless is_numeric5?('1.2.3')</syntaxhighlight> |
|||
=={{header|mIRC Scripting Language}}== |
=={{header|mIRC Scripting Language}}== |
||
{{works with|mIRC}} |
{{works with|mIRC}} |
||
<syntaxhighlight lang="mirc">var %value = 3 |
|||
if (%value isnum) { |
|||
echo -s %value is numeric. |
|||
}</syntaxhighlight> |
|||
} |
|||
=={{header|Modula-3}}== |
=={{header|Modula-3}}== |
||
<syntaxhighlight lang="modula3">MODULE Numeric EXPORTS Main; |
|||
<lang modula3> |
|||
MODULE Numeric EXPORTS Main; |
|||
IMPORT IO, Fmt, Text; |
IMPORT IO, Fmt, Text; |
||
Line 400: | Line 3,462: | ||
IO.Put("isNumeric(-3.1415926) = " & Fmt.Bool(isNumeric("-3.1415926")) & "\n"); |
IO.Put("isNumeric(-3.1415926) = " & Fmt.Bool(isNumeric("-3.1415926")) & "\n"); |
||
IO.Put("isNumeric(Foo123) = " & Fmt.Bool(isNumeric("Foo123")) & "\n"); |
IO.Put("isNumeric(Foo123) = " & Fmt.Bool(isNumeric("Foo123")) & "\n"); |
||
END Numeric. |
END Numeric.</syntaxhighlight> |
||
</lang> |
|||
{{out}} |
|||
Output: |
|||
<pre> |
<pre> |
||
isNumeric(152) = TRUE |
isNumeric(152) = TRUE |
||
Line 409: | Line 3,470: | ||
isNumeric(Foo123) = FALSE |
isNumeric(Foo123) = FALSE |
||
</pre> |
</pre> |
||
=={{header|MUMPS}}== |
|||
<p>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.</p> |
|||
<p>Examples from command line:<pre> |
|||
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 |
|||
</pre></p> |
|||
<p>There is a function, $ISVALIDNUM, to do the testing.<pre> |
|||
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</pre> |
|||
=={{header|Nanoquery}}== |
|||
<syntaxhighlight lang="nanoquery">def isNum(str) |
|||
try |
|||
double(str) |
|||
return true |
|||
catch |
|||
return false |
|||
end |
|||
end</syntaxhighlight> |
|||
=={{header|Nemerle}}== |
|||
<syntaxhighlight lang="nemerle">using System; |
|||
using System.Console; |
|||
module IsNumeric |
|||
{ |
|||
IsNumeric( input : string) : bool |
|||
{ |
|||
mutable meh = 0.0; // I don't want it, not going to use it, why force me to declare it? |
|||
double.TryParse(input, out meh) |
|||
} |
|||
Main() : void |
|||
{ |
|||
def num = "-1.2345E6"; |
|||
def not = "abc45"; |
|||
WriteLine($"$num is numeric: $(IsNumeric(num))"); |
|||
WriteLine($"$not is numeric: $(IsNumeric(not))"); |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|NetRexx}}== |
|||
<syntaxhighlight lang="netrexx">/* NetRexx */ |
|||
options replace format comments java crossref symbols nobinary |
|||
numeric digits 20 |
|||
loop n_ over getTestData() |
|||
-- could have used n_.datatype('N') directly here... |
|||
if isNumeric(n_) then msg = 'numeric' |
|||
else msg = 'not numeric' |
|||
say ('"'n_'"').right(25)':' msg |
|||
end n_ |
|||
return |
|||
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
-- Pointless in NetRexx; the DATATYPE built-in-function is more powerful! |
|||
method isNumeric(testString) public static returns boolean |
|||
return testString.datatype('N') |
|||
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
|||
method getTestData() private static returns Rexx[] |
|||
-- Coercing numbers into the Rexx type has the effect of converting them to strings. |
|||
-- NetRexx will still perform arithmetic on Rexx strings if those strings represent numbers. |
|||
-- Notice that whitespace between the sign and the number are ignored even when inside a string constant |
|||
testData = [ Rexx - |
|||
' one and a half', 1, 1.5, 1.5e+27, ' 1 ', ' 1.5 ', ' 1.5e+27 ', - |
|||
'-one and a half', - 1, - 1.5, - 1.5e-27, ' - 1 ', '- 1.5 ', '- 1.5e-27 ', - |
|||
'+one and a half', + 1, + 1.5, + 1.5e+27, ' + 1 ', '+ 1.5 ', '+ 1.5e+27 ', - |
|||
'Math Constants', - |
|||
Math.PI, Math.E, - |
|||
-Math.PI, -Math.E, - |
|||
+Math.PI, +Math.E, - |
|||
'Numeric Constants', - |
|||
Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY - |
|||
] |
|||
return testData |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
" one and a half": not numeric |
|||
"1": numeric |
|||
"1.5": numeric |
|||
"1.5e+27": numeric |
|||
" 1 ": numeric |
|||
" 1.5 ": numeric |
|||
" 1.5e+27 ": numeric |
|||
"-one and a half": not numeric |
|||
"-1": numeric |
|||
"-1.5": numeric |
|||
"-1.5E-27": numeric |
|||
" - 1 ": numeric |
|||
"- 1.5 ": numeric |
|||
"- 1.5e-27 ": numeric |
|||
"+one and a half": not numeric |
|||
"1": numeric |
|||
"1.5": numeric |
|||
"1.5E+27": numeric |
|||
" + 1 ": numeric |
|||
"+ 1.5 ": numeric |
|||
"+ 1.5e+27 ": numeric |
|||
"Math Constants": not numeric |
|||
"3.141592653589793": numeric |
|||
"2.718281828459045": numeric |
|||
"-3.141592653589793": numeric |
|||
"-2.718281828459045": numeric |
|||
"3.141592653589793": numeric |
|||
"2.718281828459045": numeric |
|||
"Numeric Constants": not numeric |
|||
"NaN": not numeric |
|||
"Infinity": not numeric |
|||
"Infinity": not numeric |
|||
</pre> |
|||
=={{header|Nim}}== |
|||
<syntaxhighlight lang="nim">import strutils |
|||
proc isNumeric(s: string): bool = |
|||
try: |
|||
discard s.parseFloat() |
|||
result = true |
|||
except ValueError: |
|||
result = false |
|||
const Strings = ["1", "3.14", "-100", "1e2", "Inf", "rose"] |
|||
for s in Strings: |
|||
echo s, " is ", if s.isNumeric(): "" else: "not ", "numeric"</syntaxhighlight> |
|||
We could prefer to use the “parsutils” module which avoids the exception: |
|||
<syntaxhighlight lang="nim">import parseutils |
|||
proc isNumeric(s: string): bool = |
|||
var x: float |
|||
s.parseFloat(x) == s.len |
|||
const Strings = ["1", "3.14", "-100", "1e2", "Inf", "rose"] |
|||
for s in Strings: |
|||
echo s, " is ", if s.isNumeric(): "" else: "not ", "numeric"</syntaxhighlight> |
|||
{{out}} |
|||
<pre>1 is numeric |
|||
3.14 is numeric |
|||
-100 is numeric |
|||
1e2 is numeric |
|||
Inf is numeric |
|||
rose is not numeric</pre> |
|||
=={{header|Nu}}== |
|||
<syntaxhighlight lang="nu"> |
|||
def is-numeric [] {try {into float | true} catch {false}} |
|||
["1" "12" "-3" "5.6" "-3.14" "one" "cheese"] | each {{k: $in, v: ($in | is-numeric)}} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
╭───┬────────┬───────╮ |
|||
│ # │ k │ v │ |
|||
├───┼────────┼───────┤ |
|||
│ 0 │ 1 │ true │ |
|||
│ 1 │ 12 │ true │ |
|||
│ 2 │ -3 │ true │ |
|||
│ 3 │ 5.6 │ true │ |
|||
│ 4 │ -3.14 │ true │ |
|||
│ 5 │ one │ false │ |
|||
│ 6 │ cheese │ false │ |
|||
╰───┴────────┴───────╯ |
|||
</pre> |
|||
=={{header|Objeck}}== |
|||
<syntaxhighlight lang="objeck"> |
|||
class Numeric { |
|||
function : Main(args : String[]) ~ Nil { |
|||
if(args->Size() = 1) { |
|||
IsNumeric(args[0])->PrintLine(); |
|||
}; |
|||
} |
|||
function : IsNumeric(str : String) ~ Bool { |
|||
return str->IsFloat(); |
|||
} |
|||
}</syntaxhighlight> |
|||
=={{header|Objective-C}}== |
=={{header|Objective-C}}== |
||
Line 415: | Line 3,686: | ||
{{works with|GNUstep}} |
{{works with|GNUstep}} |
||
The ''NSScanner'' class supports scanning of strings for various types. The ''scanFloat'' method will return |
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''. |
||
<syntaxhighlight lang="objc">if( [[NSScanner scannerWithString:@"-123.4e5"] scanFloat:NULL] ) |
|||
<lang objc> |
|||
if( [[NSScanner scannerWithString:@"-123.4e5"] scanFloat:nil] ) |
|||
NSLog( @"\"-123.4e5\" is numeric" ); |
NSLog( @"\"-123.4e5\" is numeric" ); |
||
else |
else |
||
NSLog( @"\"-123.4e5\" is not numeric" ); |
NSLog( @"\"-123.4e5\" is not numeric" ); |
||
if( [[NSScanner scannerWithString:@"Not a number"] scanFloat: |
if( [[NSScanner scannerWithString:@"Not a number"] scanFloat:NULL] ) |
||
NSLog( @"\"Not a number\" is numeric" ); |
NSLog( @"\"Not a number\" is numeric" ); |
||
else |
else |
||
NSLog( @"\"Not a number\" is not numeric" ); |
NSLog( @"\"Not a number\" is not numeric" ); |
||
// prints: "-123.4e5" is numeric |
// prints: "-123.4e5" is numeric |
||
// prints: "Not a number" is not numeric |
// prints: "Not a number" is not numeric</syntaxhighlight> |
||
</lang> |
|||
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. |
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. |
||
<syntaxhighlight lang="objc">BOOL isNumeric(NSString *s) |
|||
<lang objc> |
|||
bool isNumeric(NSString *s) |
|||
{ |
{ |
||
NSScanner *sc = [NSScanner scannerWithString: s]; |
NSScanner *sc = [NSScanner scannerWithString: s]; |
||
if ( [sc scanFloat: |
if ( [sc scanFloat:NULL] ) |
||
{ |
{ |
||
return [sc isAtEnd]; |
return [sc isAtEnd]; |
||
} |
} |
||
return |
return NO; |
||
}</syntaxhighlight> |
|||
} |
|||
</lang> |
|||
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 |
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 |
the '+' or '-' can appear only ''attached'' to the number ("+123" returns YES, but "+ 123" returns NO). |
||
<syntaxhighlight lang="objc">BOOL isNumericI(NSString *s) |
|||
<lang objc> |
|||
bool isNumericI(NSString *s) |
|||
{ |
{ |
||
NSUInteger len = [s length]; |
NSUInteger len = [s length]; |
||
NSUInteger i; |
NSUInteger i; |
||
BOOL status = NO; |
|||
for(i=0; i < len; i++) |
for(i=0; i < len; i++) |
||
{ |
{ |
||
unichar singlechar = [s characterAtIndex: i]; |
|||
if ( ( |
if ( (singlechar == ' ') && (!status) ) |
||
{ |
{ |
||
continue; |
continue; |
||
} |
} |
||
if ( ( |
if ( ( singlechar == '+' || |
||
singlechar == '-' ) && (!status) ) { status=YES; continue; } |
|||
if ( ( |
if ( ( singlechar >= '0' ) && |
||
( |
( singlechar <= '9' ) ) |
||
{ |
{ |
||
status = |
status = YES; |
||
} else { |
} else { |
||
return |
return NO; |
||
} |
} |
||
} |
} |
||
return (i == len) && status; |
return (i == len) && status; |
||
}</syntaxhighlight> |
|||
} |
|||
</lang> |
|||
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. |
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}}== |
=={{header|OCaml}}== |
||
This function is not particularly useful in a statically typed language. Instead, one would just attempt to convert the string |
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. |
to the desired type and handle parsing failure appropriately. |
||
Line 484: | Line 3,748: | ||
The task doesn't define which strings are considered "numeric", so we do ints and floats, which should catch the most common cases: |
The task doesn't define which strings are considered "numeric", so we do ints and floats, which should catch the most common cases: |
||
<syntaxhighlight lang="ocaml">let is_int s = |
|||
<lang ocaml> |
|||
let is_int s = |
|||
try ignore (int_of_string s); true |
try ignore (int_of_string s); true |
||
with _ -> false |
with _ -> false |
||
Line 493: | Line 3,756: | ||
with _ -> false |
with _ -> false |
||
let is_numeric s = is_int s || is_float s |
let is_numeric s = is_int s || is_float s</syntaxhighlight> |
||
</lang> |
|||
=={{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. |
|||
<syntaxhighlight lang="octave">function r = isnum(a) |
|||
if ( isnumeric(a) ) |
|||
r = 1; |
|||
else |
|||
r = ~isnan(str2double(a)); |
|||
endif |
|||
endfunction |
|||
% tests |
|||
disp(isnum(123)) % 1 |
|||
disp(isnum("123")) % 1 |
|||
disp(isnum("foo123")) % 0 |
|||
disp(isnum("123bar")) % 0 |
|||
disp(isnum("3.1415")) % 1</syntaxhighlight> |
|||
=={{header|Odin}}== |
|||
<syntaxhighlight lang="odin">package main |
|||
import "core:strconv" |
|||
import "core:fmt" |
|||
is_numeric :: proc(s: string) -> bool { |
|||
_, ok := strconv.parse_f32(s) |
|||
return ok |
|||
} |
|||
main :: proc() { |
|||
strings := []string{"1", "3.14", "-100", "1e2", "Inf", "rose"} |
|||
for s in strings { |
|||
fmt.println(s, "is", is_numeric(s) ? "numeric" : "not numeric") |
|||
} |
|||
} |
|||
/* Output: |
|||
1 is numeric |
|||
3.14 is numeric |
|||
-100 is numeric |
|||
1e2 is numeric |
|||
Inf is not numeric |
|||
rose is not numeric |
|||
*/</syntaxhighlight> |
|||
=={{header|Oz}}== |
|||
<syntaxhighlight lang="oz">fun {IsNumeric S} |
|||
{String.isInt S} orelse {String.isFloat S} |
|||
end</syntaxhighlight> |
|||
=={{header|PARI/GP}}== |
|||
<syntaxhighlight lang="parigp">isNumeric(s)={ |
|||
my(t=type(eval(s))); |
|||
t == "t_INT" || t == "T_REAL" |
|||
};</syntaxhighlight> |
|||
=={{header|Pascal}}== |
|||
See [[#Delphi|Delphi]] or [[#Free Pascal|Free Pascal]]. |
|||
=={{header|PascalABC.NET}}== |
|||
<syntaxhighlight lang="pascal"> |
|||
function IsNumeric(s: string): boolean; |
|||
begin |
|||
var i: integer; |
|||
Result := integer.TryParse(s,i) |
|||
end; |
|||
begin |
|||
var s := '123'; |
|||
if IsNumeric(s) then |
|||
Print('string is numeric') |
|||
end. |
|||
</syntaxhighlight> |
|||
=={{header|PeopleCode}}== |
|||
<syntaxhighlight lang="peoplecode"> |
|||
Built-In Function |
|||
Syntax |
|||
IsNumber(Value) |
|||
Description |
|||
Use the IsNumber function to determine if Value contains a valid numeric value. Numeric characters include sign indicators and comma and period decimal points. |
|||
To determine if a value is a number and if it's in the user's local format, use the IsUserNumber function. |
|||
Parameters |
|||
Value |
|||
Specify a string you want to search to determine if it is a valid number. |
|||
Returns |
|||
A Boolean value: True if Value contains a valid numeric value, False otherwise. |
|||
Example |
|||
&Value = Get Field().Value; |
|||
If IsNumber(&Value) Then |
|||
/* do numeric processing */ |
|||
Else |
|||
/* do non-numeric processing */ |
|||
End-if; |
|||
</syntaxhighlight> |
|||
=={{header|Perl}}== |
=={{header|Perl}}== |
||
{{works with|Perl|5.8}} |
|||
<syntaxhighlight lang="perl">use Scalar::Util qw(looks_like_number); |
|||
print looks_like_number($str) ? "numeric" : "not numeric\n";</syntaxhighlight> |
|||
{{works with|Perl|5.8}} |
{{works with|Perl|5.8}} |
||
Quoting from [http://perldoc.perl.org/perlfaq4.html#How-do-I-determine-whether-a-scalar-is-a-number%2fwhole%2finteger%2ffloat%3f perlfaq4]: |
Quoting from [http://perldoc.perl.org/perlfaq4.html#How-do-I-determine-whether-a-scalar-is-a-number%2fwhole%2finteger%2ffloat%3f perlfaq4]: |
||
Line 504: | Line 3,875: | ||
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]]. |
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]]. |
||
<syntaxhighlight lang="perl">if (/\D/) { print "has nondigits\n" } |
|||
<lang perl> |
|||
if (/\ |
if (/^\d+\z/) { print "is a whole number\n" } |
||
if (/^\d+ |
if (/^-?\d+\z/) { print "is an integer\n" } |
||
if (/^-?\d+ |
if (/^[+-]?\d+\z/) { print "is a +/- integer\n" } |
||
if (/^ |
if (/^-?\d+\.?\d*\z/) { print "is a real number\n" } |
||
if (/^-?\d+\. |
if (/^-?(?:\d+(?:\.\d*)?&\.\d+)\z/) { print "is a decimal number\n" } |
||
if (/^-?(? |
if (/^([+-]?)(?=\d&\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?\z/) |
||
{ print "a C float\n" }</syntaxhighlight> |
|||
if (/^([+-]?)(?=\d&\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?$/) |
|||
{ print "a C float\n" } |
|||
</lang> |
|||
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. |
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. |
||
Line 519: | Line 3,888: | ||
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?'' |
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?'' |
||
<syntaxhighlight lang="perl">sub getnum { |
|||
<lang perl> |
|||
use POSIX; |
|||
sub getnum { |
|||
use POSIX qw(strtod); |
|||
my $str = shift; |
my $str = shift; |
||
$str =~ s/^\s+//; |
$str =~ s/^\s+//; |
||
Line 534: | Line 3,902: | ||
} |
} |
||
sub is_numeric { defined getnum($_[0]) } |
sub is_numeric { defined getnum($_[0]) }</syntaxhighlight> |
||
</lang> |
|||
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. |
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}}== |
|||
<!--<syntaxhighlight lang="phix">(phixonline)--> |
|||
<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: #000080;font-style:italic;">-- Alt: isNumberString(object s) and |
|||
-- return string(s) and scanf(s,"%f")!={}, or even |
|||
-- return string(s) and scanf(substitute(trim(s),",",""),"%f")!={}</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span> |
|||
<span style="color: #008080;">constant</span> <span style="color: #000000;">tests</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"#a"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"#A"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0xA"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0(16)A"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"#FF"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"255"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0"</span><span style="color: #0000FF;">,</span> |
|||
<span style="color: #008000;">"0."</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0.0"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"000.000"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0e0"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0e-2000"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">,</span> |
|||
<span style="color: #008000;">".14"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">".05"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"-5.2"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0xf"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"ten"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1B"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"#1B"</span><span style="color: #0000FF;">,</span> |
|||
<span style="color: #008000;">" 12 "</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">trim</span><span style="color: #0000FF;">(</span><span style="color: #008000;">" 12 "</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"1"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0o16"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0o18"</span><span style="color: #0000FF;">,</span> |
|||
<span style="color: #008000;">"0b10101111_11110000_11110000_00110011"</span><span style="color: #0000FF;">,</span> |
|||
<span style="color: #008000;">"1_000"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"50e"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"+123"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"+ 123"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"-0b10101"</span><span style="color: #0000FF;">,</span> |
|||
<span style="color: #008000;">"NaN"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"+.345"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"12..34"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"12e3.4"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0-2"</span><span style="color: #0000FF;">,</span> |
|||
<span style="color: #008000;">"192.168.0.1"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1.2e"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1 2"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"12.34"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span> |
|||
<span style="color: #008000;">"beef"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"#beef"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1,000,000"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Inf"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1/2"</span><span style="color: #0000FF;">,</span> |
|||
<span style="color: #008000;">"1.5e+27"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0x10.5"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1."</span><span style="color: #0000FF;">}</span> |
|||
<span style="color: #004080;">sequence</span> <span style="color: #000000;">numeric</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span> |
|||
<span style="color: #000000;">notnumb</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span> |
|||
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span> |
|||
<span style="color: #004080;">string</span> <span style="color: #000000;">ti</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> |
|||
<span style="color: #008080;">if</span> <span style="color: #000000;">isNumber</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> |
|||
<span style="color: #000000;">numeric</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">numeric</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">else</span> |
|||
<span style="color: #000000;">notnumb</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">notnumb</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span> |
|||
<span style="color: #008080;">end</span> <span style="color: #008080;">for</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;">"numeric: "</span><span style="color: #0000FF;">)</span> |
|||
<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">numeric</span><span style="color: #0000FF;">,{</span><span style="color: #004600;">pp_Indent</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</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> |
|||
<!--</syntaxhighlight>--> |
|||
{{out}} |
|||
<pre> |
|||
numeric: {`#a`, `#A`, `0xA`, `0(16)A`, `#FF`, `255`, `0`, `0.0`, `000.000`, |
|||
`0e0`, `0e-2000`, `.14`, `.05`, `-5.2`, `0xf`, `#1B`, `12`, `1`, |
|||
`0o16`, `0b10101111_11110000_11110000_00110011`, `1_000`, `+123`, |
|||
`-0b10101`, `+.345`, `12.34`, `#beef`, `1.5e+27`, `0x10.5`} |
|||
not numeric: {`0.`, ` `, `ten`, `1B`, ` 12 `, `0o18`, `50e`, `+ 123`, |
|||
`NaN`, `12..34`, `12e3.4`, `0-2`, `192.168.0.1`, `1.2e`, |
|||
`1 2`, ``, `beef`, `1,000,000`, `Inf`, `1/2`, `1.`} |
|||
</pre> |
|||
Should you want to check for (eg) complex numbers, your best bet is to (also) invoke scanf() with several other different format strings such as "%f+%fi", "%f-%fj" (etc), until one works, or they all fail. |
|||
=={{header|PHP}}== |
=={{header|PHP}}== |
||
<syntaxhighlight lang="php"><?php |
|||
<lang php> |
|||
<?php |
|||
$string = '123'; |
$string = '123'; |
||
if(is_numeric($string)) { |
if(is_numeric(trim($string))) { |
||
} |
} |
||
?></syntaxhighlight> |
|||
</lang> |
|||
=={{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 |
|||
<syntaxhighlight lang="picolisp">: (format "123") |
|||
-> 123 |
|||
: (format "123a45") |
|||
-> NIL |
|||
: (format "-123.45" 4) |
|||
-> 1234500</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="pike"> |
|||
int(0..1) is_number(string s) |
|||
{ |
|||
array test = array_sscanf(s, "%s%f%s"); |
|||
if (sizeof(test) == 3 && test[1] && !sizeof(test[0]) && !sizeof(test[2]) ) |
|||
return true; |
|||
else |
|||
return false; |
|||
} |
|||
string num = "-1.234" |
|||
is_number(num); |
|||
-> true |
|||
</syntaxhighlight> |
|||
=={{header|PL/I}}== |
|||
<syntaxhighlight lang="pl/i"> |
|||
is_numeric: procedure (text) returns (bit (1)); |
|||
declare text character (*); |
|||
declare x float; |
|||
on conversion go to done; |
|||
get string(text) edit (x) (E(length(text),0)); |
|||
return ('1'b); |
|||
done: |
|||
return ('0'b); |
|||
end is_numeric;</syntaxhighlight> |
|||
<pre> |
|||
5 '1'B |
|||
6.7 '1'B |
|||
-8.9 '1'B |
|||
-4e3 '1'B |
|||
4A37 '0'B |
|||
</pre> |
|||
=={{header|PL/SQL}}== |
=={{header|PL/SQL}}== |
||
<syntaxhighlight lang="plsql">FUNCTION IsNumeric( value IN VARCHAR2 ) |
|||
<lang plsql> |
|||
FUNCTION IsNumeric( value IN VARCHAR2 ) |
|||
RETURN BOOLEAN |
RETURN BOOLEAN |
||
IS |
IS |
||
Line 559: | Line 4,025: | ||
WHEN others THEN |
WHEN others THEN |
||
return( FALSE ); |
return( FALSE ); |
||
END;</syntaxhighlight> |
|||
END; |
|||
</lang> |
|||
<syntaxhighlight lang="plsql">Value VARCHAR2( 10 ) := '123'; |
|||
<lang plsql> |
|||
Value VARCHAR2( 10 ) := '123'; |
|||
IF( IsNumeric( Value ) ) |
IF( IsNumeric( Value ) ) |
||
THEN |
THEN |
||
NULL; |
NULL; |
||
END IF; |
END IF;</syntaxhighlight> |
||
</lang> |
|||
=={{header|Plain English}}== |
|||
The following decider exists in the noodle |
|||
<code>To decide if a string is any numeric literal:</code> |
|||
<br /> |
|||
and is used to resolve the If clause |
|||
<code>If the string is any numeric literal,</code> |
|||
in this solution. |
|||
<syntaxhighlight lang="plainenglish">To run: |
|||
Start up. |
|||
Show whether "cat" is numeric. |
|||
Show whether "3" is numeric. |
|||
Show whether "+3" is numeric. |
|||
Show whether "-123" is numeric. |
|||
Show whether "123,456" is numeric. |
|||
Show whether "11/5" is numeric. |
|||
Show whether "-26-1/3" is numeric. |
|||
Show whether "+26-1/3" is numeric. |
|||
Show whether "1/0" is numeric. \in Plain English, 1/0 is 0. Don't tell the mathematicians! |
|||
Show whether "3.14159" is numeric. \floating point is not implemented in Plain English. |
|||
Wait for the escape key. |
|||
Shut down. |
|||
To show whether a string is numeric: |
|||
Write the string then " -> " on the console without advancing. |
|||
If the string is any numeric literal, write "yes" on the console; exit. |
|||
Write "no" on the console.</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
cat -> no |
|||
3 -> yes |
|||
+3 -> yes |
|||
-123 -> yes |
|||
123,456 -> no |
|||
11/5 -> yes |
|||
-26-1/3 -> yes |
|||
+26-1/3 -> yes |
|||
1/0 -> yes |
|||
3.14159 -> no |
|||
</pre> |
|||
=={{header|PowerShell}}== |
|||
Note: PowerShell 1.0 does not support 'try' |
|||
THis simply tries arithmetic with the argument and if that fails, ''false'' is returned. |
|||
<syntaxhighlight lang="powershell">function isNumeric ($x) { |
|||
try { |
|||
0 + $x | Out-Null |
|||
return $true |
|||
} catch { |
|||
return $false |
|||
} |
|||
}</syntaxhighlight> |
|||
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. |
|||
<syntaxhighlight lang="powershell">function isNumeric ($x) { |
|||
$x2 = 0 |
|||
$isNum = [System.Int32]::TryParse($x, [ref]$x2) |
|||
return $isNum |
|||
}</syntaxhighlight> |
|||
=={{header|Prolog}}== |
|||
{{works with|SWI-Prolog|7}} |
|||
The code: |
|||
<syntaxhighlight lang="prolog">numeric_string(String) :- |
|||
atom_string(Atom, String), |
|||
atom_number(Atom, _).</syntaxhighlight> |
|||
A predicate to test the code: |
|||
<syntaxhighlight lang="prolog">test_strings(Strings) :- |
|||
forall( member(String, Strings), |
|||
( ( numeric_string(String) |
|||
-> Result = a |
|||
; Result = 'not a' ), |
|||
format('~w is ~w number.~n', [String, Result]) |
|||
) |
|||
).</syntaxhighlight> |
|||
Example of using the test predicate: |
|||
<syntaxhighlight lang="prolog">?- test_strings(["123", "0.123", "-123.1", "NotNum", "1."]). |
|||
123 is a number. |
|||
0.123 is a number. |
|||
-123.1 is a number. |
|||
NotNum is not a number. |
|||
1. is not a number. |
|||
true.</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="purebasic">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</syntaxhighlight> |
|||
{{out}} |
|||
<pre>'+3183.31151E+321' = 1 |
|||
'-123456789' = 1 |
|||
'123.45.6789+' = 0 |
|||
'-e' = 0</pre> |
|||
=={{header|Python}}== |
=={{header|Python}}== |
||
===Python: Simple int/float=== |
|||
<lang python> |
|||
<syntaxhighlight lang="python">def is_numeric(s): |
|||
s = '123' |
|||
try: |
try: |
||
float(s) |
|||
return True |
|||
except ValueError: |
|||
except (ValueError, TypeError): |
|||
# not numeric |
|||
return False |
|||
else: |
|||
# numeric |
|||
is_numeric('123.0')</syntaxhighlight> |
|||
</lang> |
|||
Or for positive integers only: |
Or for positive integers only: |
||
<syntaxhighlight lang="python">'123'.isdigit()</syntaxhighlight> |
|||
<lang python> |
|||
s = '123' |
|||
if s.isdigit(): |
|||
# numeric |
|||
</lang> |
|||
===Python: Most numeric literals=== |
|||
Including complex, hex, binary, and octal numeric literals we get: |
Including complex, hex, binary, and octal numeric literals we get: |
||
<syntaxhighlight lang="python">def is_numeric(literal): |
|||
<lang python> |
|||
"""Return whether a literal can be parsed as a numeric value""" |
|||
def is_numeric(lit): |
|||
castings = [int, float, complex, |
|||
'Return value of numeric literal string or ValueError exception' |
|||
lambda s: int(s,2), #binary |
|||
lambda s: int(s,8), #octal |
|||
lambda s: int(s,16)] #hex |
|||
for cast in castings: |
|||
try: |
|||
cast(literal) |
|||
return True |
|||
except ValueError: |
|||
pass |
|||
return False</syntaxhighlight> |
|||
Sample use, including value parsed, its type, and standard method str.isnumeric(): |
|||
# Hex/Binary |
|||
<syntaxhighlight lang="python">def numeric(literal): |
|||
litneg = lit[1:] if lit[0] == '-' else lit |
|||
"""Return value of numeric literal or None if can't parse a value""" |
|||
if litneg[0] == '0': |
|||
castings = [int, float, complex, |
|||
if litneg[1] in 'xX': |
|||
lambda s: int(s,2), #binary |
|||
lambda s: int(s,8), #octal |
|||
lambda s: int(s,16)] #hex |
|||
for cast in castings: |
|||
try: |
|||
return cast(literal) |
|||
except ValueError: |
|||
pass |
|||
return None |
|||
# Int/Float/Complex |
|||
try: |
|||
return int(lit) |
|||
except ValueError: |
|||
pass |
|||
try: |
|||
return float(lit) |
|||
except ValueError: |
|||
pass |
|||
return complex(lit) |
|||
</lang> |
|||
Sample use: |
|||
<lang python> |
|||
>>> for s in ['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))) |
|||
tests = [ |
|||
'0', '0.', '00', '123', '0123', '+123', '-123', '-123.', '-123e-4', '-.8E-04', |
|||
'0.123', '(5)', '-123+4.5j', '0b0101', ' +0B101 ', '0o123', '-0xABC', '0x1a1', |
|||
'12.5%', '1/2', '½', '3¼', 'π', 'Ⅻ', '1,000,000', '1 000', '- 001.20e+02', |
|||
'NaN', 'inf', '-Infinity'] |
|||
for s in tests: |
|||
print("%14s -> %-14s %-20s is_numeric: %-5s str.isnumeric: %s" % ( |
|||
'"'+s+'"', numeric(s), type(numeric(s)), is_numeric(s), s.isnumeric() ))</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
"0" -> 0 <class 'int'> is_numeric: True str.isnumeric: True |
|||
"0." -> 0.0 <class 'float'> is_numeric: True str.isnumeric: False |
|||
"00" -> 0 <class 'int'> is_numeric: True str.isnumeric: True |
|||
"123" -> 123 <class 'int'> is_numeric: True str.isnumeric: True |
|||
"0123" -> 123 <class 'int'> is_numeric: True str.isnumeric: True |
|||
"+123" -> 123 <class 'int'> is_numeric: True str.isnumeric: False |
|||
"-123" -> -123 <class 'int'> is_numeric: True str.isnumeric: False |
|||
"-123." -> -123.0 <class 'float'> is_numeric: True str.isnumeric: False |
|||
"-123e-4" -> -0.0123 <class 'float'> is_numeric: True str.isnumeric: False |
|||
"-.8E-04" -> -8e-05 <class 'float'> is_numeric: True str.isnumeric: False |
|||
"0.123" -> 0.123 <class 'float'> is_numeric: True str.isnumeric: False |
|||
"(5)" -> (5+0j) <class 'complex'> is_numeric: True str.isnumeric: False |
|||
"-123+4.5j" -> (-123+4.5j) <class 'complex'> is_numeric: True str.isnumeric: False |
|||
"0b0101" -> 5 <class 'int'> is_numeric: True str.isnumeric: False |
|||
" +0B101 " -> 5 <class 'int'> is_numeric: True str.isnumeric: False |
|||
"0o123" -> 83 <class 'int'> is_numeric: True str.isnumeric: False |
|||
"-0xABC" -> -2748 <class 'int'> is_numeric: True str.isnumeric: False |
|||
"0x1a1" -> 417 <class 'int'> is_numeric: True str.isnumeric: False |
|||
"12.5%" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False |
|||
"1/2" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False |
|||
"½" -> None <class 'NoneType'> is_numeric: False str.isnumeric: True |
|||
"3¼" -> None <class 'NoneType'> is_numeric: False str.isnumeric: True |
|||
"π" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False |
|||
"Ⅻ" -> None <class 'NoneType'> is_numeric: False str.isnumeric: True |
|||
"1,000,000" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False |
|||
"1 000" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False |
|||
"- 001.20e+02" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False |
|||
"NaN" -> nan <class 'float'> is_numeric: True str.isnumeric: False |
|||
"inf" -> inf <class 'float'> is_numeric: True str.isnumeric: False |
|||
"-Infinity" -> -inf <class 'float'> is_numeric: True str.isnumeric: False</pre> |
|||
===Python: Regular expressions=== |
|||
<syntaxhighlight lang="python">import re |
|||
numeric = re.compile('[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?') |
|||
is_numeric = lambda x: numeric.fullmatch(x) != None |
|||
is_numeric('123.0')</syntaxhighlight> |
|||
=={{header|Quackery}}== |
|||
<syntaxhighlight lang="quackery"> [ char . over find |
|||
tuck over found iff |
|||
[ swap pluck drop ] |
|||
else nip ] is -point ( $ --> $ ) |
|||
[ -point $->n nip ] is numeric ( $ --> b ) |
|||
[ dup echo$ say " is" |
|||
numeric not if say " not" |
|||
say " a valid number." cr ] is task ( $ --> ) |
|||
$ "152" task |
|||
$ "-3.1415926" task |
|||
$ "Foo123" task</syntaxhighlight> |
|||
{{out}} |
|||
<pre>152 is a valid number. |
|||
-3.1415926 is a valid number. |
|||
Foo123 is not a valid number.</pre> |
|||
=={{header|R}}== |
|||
<syntaxhighlight lang="r">> strings <- c("152", "-3.1415926", "Foo123") |
|||
> suppressWarnings(!is.na(as.numeric(strings))) |
|||
[1] TRUE TRUE FALSE |
|||
</syntaxhighlight> |
|||
=={{header|Racket}}== |
|||
<syntaxhighlight lang="racket">(define (string-numeric? s) (number? (string->number s)))</syntaxhighlight> |
|||
Or, since all non-<tt>#f</tt> are true: |
|||
<syntaxhighlight lang="racket">(define string-numeric? string->number)</syntaxhighlight> |
|||
=={{header|Raku}}== |
|||
(formerly Perl 6) |
|||
{{works with|Rakudo|2017.11}} |
|||
Raku tries very hard to DWIM (do what I mean). As part of that, numeric strings are by default stored as allomorphic types which can be used as numbers or strings without any conversion. If we truly want to operate on strings, we have to explicitly coerce the allomorphs to strings. A subtlety that may not be immediately apparent, whitespace, empty strings and null strings may be treated as (False) boolean values in Raku, however booleans are allomorphic to numeric, so empty strings will coerce to a numeric value (0), and return as numeric unless specifically checked for. Interestingly, the actual strings 'True' and 'False' '''don't''' evaluate as numeric. (because there are no String | Boolean allomorphs.) |
|||
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. |
|||
<syntaxhighlight lang="raku" line>sub is-number-w-ws( Str $term --> Bool ) { # treat Falsey strings as numeric |
|||
$term.Numeric !~~ Failure; |
|||
} |
|||
sub is-number-wo-ws( Str $term --> Bool ) { # treat Falsey strings as non-numeric |
|||
?($term ~~ / \S /) && $term.Numeric !~~ Failure; |
|||
} |
|||
say " Coerce Don't coerce"; |
|||
say ' String whitespace whitespace'; |
|||
printf "%10s %8s %11s\n", |
|||
"<$_>", .&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 |
|||
0o18 2+5i True False Inf NaN 0x10.50 0b102 0o_5_3 ௫௯>, ' 12 ', '1 1 1', '', ' ' ).map: *.Str;</syntaxhighlight> |
|||
<pre> Coerce Don't coerce |
|||
String whitespace whitespace |
|||
<1> True True |
|||
<1.2> True True |
|||
<1.2.3> False False |
|||
<-6> True True |
|||
<1/2> True True |
|||
<12e> False False |
|||
<B17> False False |
|||
<1.3e+12> True True |
|||
<1.3e12> True True |
|||
<-2.6e-3> True True |
|||
<zero> False False |
|||
<0x> False False |
|||
<0xA10> True True |
|||
<0b1001> True True |
|||
<0o16> True True |
|||
<0o18> False False |
|||
<2+5i> True True |
|||
<True> False False |
|||
<False> False False |
|||
<Inf> True True |
|||
<NaN> True True |
|||
<0x10.50> True True |
|||
<0b102> False False |
|||
<0o_5_3> True True |
|||
<௫௯> True True |
|||
< 12 > True True |
|||
<1 1 1> False False |
|||
<> True False |
|||
< > True False</pre> |
|||
=={{header|RapidQ}}== |
|||
<syntaxhighlight lang="rapidq">isnumeric |
|||
$Typecheck on |
|||
Defint FALSE, TRUE |
|||
FALSE = 0 |
|||
TRUE = NOT FALSE |
|||
Function isNumeric(s as string, optchar as string) as integer |
|||
If len(s) = 0 then |
|||
Result = FALSE |
|||
Exit Function |
|||
End If |
|||
if instr(s,"+") > 1 then |
|||
Result = FALSE |
|||
exit function |
|||
end if |
|||
if instr(s,"-") > 1 then |
|||
Result = FALSE |
|||
exit function |
|||
end if |
|||
Defint i, ndex = 0 |
|||
For i = 1 to len(s) |
|||
select case asc(mid$(s,i,1)) |
|||
case 43 '+ |
|||
case 45 '- |
|||
case 46 '. |
|||
if ndex = 1 then |
|||
Result = FALSE |
|||
Exit function |
|||
end if |
|||
ndex = 1 |
|||
case 48 to 57 '0 to 9 |
|||
case else |
|||
if instr(optchar,(mid$(s,i,1))) = 0 then |
|||
Result = FALSE |
|||
exit function |
|||
end if |
|||
end select |
|||
next |
|||
Result = TRUE |
|||
End Function |
|||
'============================================================ |
|||
'Begin |
|||
'============================================================ |
|||
showmessage (str$(isNumeric("-152.34",""))) |
|||
end |
|||
</syntaxhighlight> |
|||
=={{header|REBOL}}== |
|||
<syntaxhighlight lang="rebol"> |
|||
REBOL [ |
|||
Title: "Is Numeric?" |
|||
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]] |
|||
</syntaxhighlight> |
|||
=={{header|Retro}}== |
|||
Retro does not have floating point numbers as part of the core system. For others, this can be done with: |
|||
<syntaxhighlight lang="retro">'123 a:from-string TRUE [ swap c:digit? and ] a:reduce</syntaxhighlight> |
|||
=={{header|REXX}}== |
|||
<syntaxhighlight lang="rexx">/*REXX program determines if a string is numeric, using REXX's rules for numbers. */ |
|||
yyy=' -123.78' /*or some such. */ |
|||
/*strings below are all numeric (REXX).*/ |
|||
zzz= ' -123.78 ' |
|||
zzz= '-123.78' |
|||
zzz= '2' |
|||
zzz= "2" |
|||
zzz= 2 |
|||
zzz= '000000000004' |
|||
zzz= '+5' |
|||
zzz= +5 |
|||
zzz= ' +6 ' |
|||
zzz= ' + 7 ' |
|||
zzz= ' - 8 ' |
|||
zzz= ' - .9' |
|||
zzz= '- 19.' |
|||
zzz= '.7' |
|||
zzz= .7 |
|||
zzz= '2e3' |
|||
zzz= 47e567 |
|||
zzz= '2e-3' |
|||
zzz= '1.2e1' |
|||
zzz= ' .2E6' |
|||
zzz= ' 2.e5 ' |
|||
zzz= ' +1.2E0002 ' |
|||
zzz= ' +1.2e+002 ' |
|||
zzz= ' +0000001.200e+002 ' |
|||
zzz= ' - 000001.200e+002 ' |
|||
zzz= ' - 000008.201e-00000000000000002 ' |
|||
/*Note: some REXX interpreters allow use of tab chars as blanks. */ |
|||
/*all statements below are equivalent.*/ |
|||
if \datatype(yyy, 'n') then say 'oops, not numeric:' yyy |
|||
if \datatype(yyy, 'N') then say 'oops, not numeric:' yyy |
|||
if ¬datatype(yyy, 'N') then say 'oops, not numeric:' yyy |
|||
if ¬datatype(yyy, 'numeric') then say 'oops, not numeric:' yyy |
|||
if ¬datatype(yyy, 'nimrod.') then say 'oops, not numeric:' yyy |
|||
if datatype(yyy) \== 'NUM' then say 'oops, not numeric:' yyy |
|||
if datatype(yyy) /== 'NUM' then say 'oops, not numeric:' yyy |
|||
if datatype(yyy) ¬== 'NUM' then say 'oops, not numeric:' yyy |
|||
if datatype(yyy) ¬= 'NUM' then say 'oops, not numeric:' yyy |
|||
/*note: REXX only looks at the first char for DATATYPE's 2nd argument.*/ |
|||
/*note: some REXX interpreters don't support the ¬ (not) character. */</syntaxhighlight> |
|||
=={{header|Ring}}== |
|||
<syntaxhighlight lang="ring"> |
|||
see isdigit("0123456789") + nl + # print 1 |
|||
isdigit("0123a") # print 0 |
|||
</syntaxhighlight> |
|||
=={{header|RPL}}== |
|||
"123" -> 123 <type 'int'> |
|||
This one-liner returns 1 if the string is either a real number, a complex number or a binary integer - and zero otherwise. |
|||
"-123." -> -123.0 <type 'float'> |
|||
≪ '''IFERR''' STR→ '''THEN''' DROP 0 '''ELSE''' TYPE { 0 1 10 } SWAP POS SIGN '''END''' ≫ ‘<span style="color:blue">NUM?</span>’ STO |
|||
"-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'> |
|||
>>> |
|||
</lang> |
|||
=={{header|Ruby}}== |
=={{header|Ruby}}== |
||
<syntaxhighlight lang="ruby">def is_numeric?(s) |
|||
<lang ruby> |
|||
begin |
|||
value=123 |
|||
Float(s) |
|||
if Numeric===value |
|||
rescue |
|||
false # not numeric |
|||
</lang> |
|||
else |
|||
true # numeric |
|||
end |
|||
end</syntaxhighlight> |
|||
or more compact: |
|||
<syntaxhighlight lang="ruby">def is_numeric?(s) |
|||
!!Float(s) rescue false |
|||
end</syntaxhighlight> |
|||
'''NB!''' Since Ruby 2.6 you no longer need `rescue`: |
|||
<syntaxhighlight lang="ruby">def is_numeric?(s) |
|||
!!Float(s, exception: false) |
|||
end</syntaxhighlight> |
|||
Adding `exception: false` will make it return `nil` instead. |
|||
'''sample''' |
|||
<syntaxhighlight lang="ruby">strings = %w(0 0.0 -123 abc 0x10 0xABC 123a -123e3 0.1E-5 50e) |
|||
strings.each do |str| |
|||
puts "%9p => %s" % [str, is_numeric?(str)] |
|||
end</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
"0" => true |
|||
"0.0" => true |
|||
"-123" => true |
|||
"abc" => false |
|||
"0x10" => true |
|||
"0xABC" => true |
|||
"123a" => false |
|||
"-123e3" => true |
|||
"0.1E-5" => true |
|||
"50e" => false |
|||
</pre> |
|||
=={{header|Run BASIC}}== |
|||
<syntaxhighlight lang="runbasic">print isNumeric("123") |
|||
print isNumeric("1ab") |
|||
' ------------------------ |
|||
' Numeric Check |
|||
' 0 = bad |
|||
' 1 = good |
|||
' ------------------------ |
|||
FUNCTION isNumeric(f$) |
|||
isNumeric = 1 |
|||
f$ = trim$(f$) |
|||
if left$(f$,1) = "-" or left$(f$,1) = "+" then f$ = mid$(f$,2) |
|||
for i = 1 to len(f$) |
|||
d$ = mid$(f$,i,1) |
|||
if d$ = "," then goto [nxtDigit] |
|||
if d$ = "." then |
|||
if dot$ = "." then isNumeric = 0 |
|||
dot$ = "." |
|||
goto [nxtDigit] |
|||
end if |
|||
if (d$ < "0") or (d$ > "9") then isNumeric = 0 |
|||
[nxtDigit] |
|||
next i |
|||
END FUNCTION</syntaxhighlight><pre>123 1 |
|||
1ab 0</pre> |
|||
=={{header|Rust}}== |
|||
<syntaxhighlight lang="rust"> |
|||
// This function is not limited to just numeric types but rather anything that implements the FromStr trait. |
|||
fn parsable<T: FromStr>(s: &str) -> bool { |
|||
s.parse::<T>().is_ok() |
|||
} |
|||
</syntaxhighlight> |
|||
Sample code: |
|||
<syntaxhighlight lang="rust"> |
|||
use std::str::FromStr; |
|||
fn parsable<T: FromStr>(s: &str) -> bool { |
|||
s.parse::<T>().is_ok() |
|||
} |
|||
fn main() { |
|||
let test_cases = [ |
|||
"142857", |
|||
"3.14", |
|||
"not of this earth!" |
|||
]; |
|||
let types: &[(&str, fn(&str) -> bool)] = &[ |
|||
("i32", parsable::<i32> as fn(&str) -> bool), |
|||
("i64", parsable::<i32> as fn(&str) -> bool), |
|||
("i128", parsable::<i32> as fn(&str) -> bool), |
|||
("f64", parsable::<f64> as fn(&str) -> bool), |
|||
]; |
|||
println!(""); |
|||
for &case in &test_cases { |
|||
for &(type_name, parse_fn) in types { |
|||
println!( |
|||
"'{}' {} be parsed as {}", |
|||
case, |
|||
if parse_fn(case) { "can" } else { "_cannot_" }, |
|||
type_name |
|||
); |
|||
} |
|||
println!(""); |
|||
} |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
'142857' can be parsed as i32 |
|||
'142857' can be parsed as i64 |
|||
'142857' can be parsed as i128 |
|||
'142857' can be parsed as f64 |
|||
'3.14' _cannot_ be parsed as i32 |
|||
'3.14' _cannot_ be parsed as i64 |
|||
'3.14' _cannot_ be parsed as i128 |
|||
'3.14' can be parsed as f64 |
|||
'not of this earth!' _cannot_ be parsed as i32 |
|||
'not of this earth!' _cannot_ be parsed as i64 |
|||
'not of this earth!' _cannot_ be parsed as i128 |
|||
'not of this earth!' _cannot_ be parsed as f64 |
|||
</pre> |
|||
=={{header|Scala}}== |
|||
<syntaxhighlight lang="scala"> |
|||
import scala.util.control.Exception.allCatch |
|||
def isNumber(s: String): Boolean = (allCatch opt s.toDouble).isDefined |
|||
</syntaxhighlight> |
|||
<syntaxhighlight lang="scala"> |
|||
def isNumeric(input: String): Boolean = input.forall(_.isDigit) |
|||
</syntaxhighlight> |
|||
Or a more complete version, using a complex regular expression: |
|||
<syntaxhighlight lang="scala"> |
|||
def isNumeric2(str: String): Boolean = { |
|||
str.matches(s"""[+-]?((\d+(e\d+)?[lL]?)|(((\d+(\.\d*)?)|(\.\d+))(e\d+)?[fF]?))""") |
|||
} |
|||
</syntaxhighlight> |
|||
Or using the built-in number parsing and catching exceptions: |
|||
<syntaxhighlight lang="scala"> |
|||
def isNumeric(str: String): Boolean = { |
|||
!throwsNumberFormatException(str.toLong) || !throwsNumberFormatException(str.toDouble) |
|||
} |
|||
def throwsNumberFormatException(f: => Any): Boolean = { |
|||
try { f; false } catch { case e: NumberFormatException => true } |
|||
} |
|||
</syntaxhighlight> |
|||
=={{header|Scheme}}== |
=={{header|Scheme}}== |
||
string->number returns #f when the string is not numeric and otherwise the number, which is non-#f and therefore true. |
string->number returns #f when the string is not numeric and otherwise the number, which is non-#f and therefore true. |
||
<syntaxhighlight lang="scheme">(define (numeric? s) (string->number s))</syntaxhighlight> |
|||
<lang scheme> |
|||
(define (numeric? s) (string->number s)) |
|||
=={{header|Seed7}}== |
|||
</lang> |
|||
The function isNumeric uses the function [http://seed7.sourceforge.net/libraries/scanstri.htm#getNumber%28inout_string%29 getNumber] from the library [http://seed7.sourceforge.net/libraries/scanstri.htm scanstri.s7i]. |
|||
GetNumber reads a numeric literal from a string. The numeric literal is removed from the input string. |
|||
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i"; |
|||
include "scanstri.s7i"; |
|||
const func boolean: isNumeric (in var string: stri) is func |
|||
result |
|||
var boolean: isNumeric is FALSE; |
|||
local |
|||
var string: numberStri is ""; |
|||
begin |
|||
numberStri := getNumber(stri); |
|||
isNumeric := stri = ""; |
|||
end func;</syntaxhighlight> |
|||
=={{header|Sidef}}== |
|||
There is the the ''String.looks_like_number'' method, which returns true when a given strings looks like a number: |
|||
<syntaxhighlight lang="ruby">say "0.1E-5".looks_like_number; #=> true</syntaxhighlight> |
|||
Alternatively, we can use regular expressions to determine this: |
|||
<syntaxhighlight lang="ruby">func is_numeric(s) { |
|||
(s ~~ /^[+-]?+(?=\.?[0-9])[0-9_]*+(?:\.[0-9_]++)?(?:[Ee](?:[+-]?+[0-9_]+))?\z/) || |
|||
(s ~~ /^0(?:b[10_]*|x[0-9A-Fa-f_]*|[0-9_]+\b)\z/) |
|||
}</syntaxhighlight> |
|||
Sample: |
|||
<syntaxhighlight lang="ruby">var strings = %w(0 0.0 -123 abc 0x10 0xABC 123a -123e3 0.1E-5 50e); |
|||
for str in strings { |
|||
say ("%9s => %s" % (str, is_numeric(str))) |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
0 => true |
|||
0.0 => true |
|||
-123 => true |
|||
abc => false |
|||
0x10 => true |
|||
0xABC => true |
|||
123a => false |
|||
-123e3 => true |
|||
0.1E-5 => true |
|||
50e => false |
|||
</pre> |
|||
=={{header|Simula}}== |
|||
Simula uses the '&' instead of 'e' or 'E' for the exponent part of a floating point decimal number. |
|||
<syntaxhighlight lang="simula">BEGIN |
|||
BOOLEAN PROCEDURE ISNUMERIC(W); TEXT W; |
|||
BEGIN |
|||
BOOLEAN PROCEDURE MORE; |
|||
MORE := W.MORE; |
|||
CHARACTER PROCEDURE NEXT; |
|||
NEXT := IF MORE THEN W.GETCHAR ELSE CHAR(0); |
|||
CHARACTER PROCEDURE LAST; |
|||
LAST := IF W.LENGTH = 0 |
|||
THEN CHAR(0) |
|||
ELSE W.SUB(W.LENGTH,1).GETCHAR; |
|||
CHARACTER CH; |
|||
W.SETPOS(1); |
|||
IF MORE THEN |
|||
BEGIN |
|||
CH := NEXT; |
|||
IF CH = '-' OR CH = '+' THEN CH := NEXT; |
|||
WHILE DIGIT(CH) DO CH := NEXT; |
|||
IF CH = '.' THEN |
|||
BEGIN |
|||
CH := NEXT; |
|||
IF NOT DIGIT(CH) THEN GOTO L; |
|||
WHILE DIGIT(CH) DO CH := NEXT; |
|||
END; |
|||
IF CH = '&' THEN |
|||
BEGIN |
|||
CH := NEXT; |
|||
IF CH = '-' OR CH = '+' THEN CH := NEXT; |
|||
WHILE DIGIT(CH) DO CH := NEXT; |
|||
END; |
|||
END; |
|||
L: ISNUMERIC := (W.LENGTH > 0) AND THEN (NOT MORE) AND THEN DIGIT(LAST); |
|||
END; |
|||
REAL X; |
|||
TEXT T; |
|||
FOR X := 0, -3.1415, 2.768&+31, 5&10, .5, 5.&10 DO |
|||
BEGIN |
|||
OUTREAL(X, 10, 20); |
|||
OUTIMAGE; |
|||
END; |
|||
OUTIMAGE; |
|||
FOR T :- "0", "-3.1415", "2.768&+31", ".5", "5&22" DO |
|||
BEGIN |
|||
OUTTEXT(IF ISNUMERIC(T) THEN " NUMERIC " ELSE "NOT NUMERIC "); |
|||
OUTCHAR('"'); |
|||
OUTTEXT(T); |
|||
OUTCHAR('"'); |
|||
IF T = "0" THEN OUTCHAR(CHAR(9)); OUTCHAR(CHAR(9)); |
|||
COMMENT PROBE ; |
|||
X := T.GETREAL; |
|||
OUTREAL(X, 10, 20); |
|||
OUTIMAGE; |
|||
END; |
|||
OUTIMAGE; |
|||
X := 5.&10; |
|||
!X := 5&; |
|||
!X := 5.; |
|||
X := .5; |
|||
FOR T :- "", "5.", "5&", "5&+", "5.&", "5.&-", "5.&10" DO |
|||
BEGIN |
|||
OUTTEXT(IF ISNUMERIC(T) THEN " NUMERIC " ELSE "NOT NUMERIC "); |
|||
OUTCHAR('"'); |
|||
OUTTEXT(T); |
|||
OUTCHAR('"'); |
|||
OUTIMAGE; |
|||
END; |
|||
END |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
0.000000000&+000 |
|||
-3.141500000&+000 |
|||
2.768000000&+031 |
|||
5.000000000&+010 |
|||
5.000000000&-001 |
|||
5.100000000&+000 |
|||
NUMERIC "0" 0.000000000&+000 |
|||
NUMERIC "-3.1415" -3.141500000&+000 |
|||
NUMERIC "2.768&+31" 2.768000000&+031 |
|||
NUMERIC ".5" 5.000000000&-001 |
|||
NUMERIC "5&22" 5.000000000&+022 |
|||
NOT NUMERIC "" |
|||
NOT NUMERIC "5." |
|||
NOT NUMERIC "5&" |
|||
NOT NUMERIC "5&+" |
|||
NOT NUMERIC "5.&" |
|||
NOT NUMERIC "5.&-" |
|||
NOT NUMERIC "5.&10" |
|||
</pre> |
|||
=={{header|Smalltalk}}== |
|||
{{works with|GNU Smalltalk}} |
|||
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... |
|||
<syntaxhighlight lang="smalltalk">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 ]</syntaxhighlight> |
|||
{{works with|Smalltalk/X}} |
|||
{{works with|GNU Smalltalk}} |
|||
(should work with all) |
|||
<syntaxhighlight lang="smalltalk">(Number readFrom:(aString readStream) onError:[nil]) notNil</syntaxhighlight> |
|||
to handle radix numbers (such as 2r10111), use: |
|||
<syntaxhighlight lang="smalltalk">(Scanner scanNumberFrom:(aString readStream)) notNil</syntaxhighlight> |
|||
=={{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. |
|||
<syntaxhighlight lang="snobol4"> 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</syntaxhighlight> |
|||
{{out}} |
|||
<pre>T: 123 |
|||
T: 123.0 |
|||
T: 123. |
|||
T: -123 |
|||
T: 3.14159 |
|||
F: 1.2.3 |
|||
F: abc |
|||
F: A440</pre> |
|||
=={{header|SQL}}== |
=={{header|SQL}}== |
||
{{works with|MS SQL|Server 2005}} |
{{works with|MS SQL|Server 2005}} |
||
<syntaxhighlight lang="sql">declare @s varchar(10) |
|||
<lang sql> |
|||
declare @s varchar(10) |
|||
set @s = '1234.56' |
set @s = '1234.56' |
||
Line 659: | Line 4,917: | ||
if isnumeric(@s)=1 begin print 'Numeric' end |
if isnumeric(@s)=1 begin print 'Numeric' end |
||
else print 'Non-numeric' |
else print 'Non-numeric'</syntaxhighlight> |
||
</lang> |
|||
=={{header|SQL PL}}== |
|||
{{works with|Db2 LUW}} version 9.7 or higher. |
|||
With SQL PL: |
|||
<syntaxhighlight lang="sql pl"> |
|||
--#SET TERMINATOR @ |
|||
CREATE OR REPLACE FUNCTION IS_NUMERIC ( |
|||
IN STRING VARCHAR(10) |
|||
) RETURNS SMALLINT |
|||
-- ) RETURNS BOOLEAN |
|||
BEGIN |
|||
DECLARE RET SMALLINT; |
|||
-- DECLARE RET BOOLEAN; |
|||
DECLARE TMP INTEGER; |
|||
DECLARE CONTINUE HANDLER FOR SQLSTATE '22018' |
|||
SET RET = 1; |
|||
-- SET RET = FALSE; |
|||
SET RET = 0; |
|||
--SET RET = TRUE; |
|||
SET TMP = INTEGER(STRING); |
|||
RETURN RET; |
|||
END @ |
|||
VALUES IS_NUMERIC('5')@ |
|||
VALUES IS_NUMERIC('0')@ |
|||
VALUES IS_NUMERIC('-1')@ |
|||
VALUES IS_NUMERIC('A')@ |
|||
VALUES IS_NUMERIC('-')@ |
|||
VALUES IS_NUMERIC('z')@ |
|||
VALUES IS_NUMERIC('')@ |
|||
VALUES IS_NUMERIC(' ')@ |
|||
</syntaxhighlight> |
|||
Output: |
|||
<pre> |
|||
db2 -td@ |
|||
db2 => BEGIN |
|||
... |
|||
db2 (cont.) => END @ |
|||
DB20000I The SQL command completed successfully. |
|||
VALUES IS_NUMERIC('5') |
|||
1 |
|||
------ |
|||
0 |
|||
1 record(s) selected. |
|||
VALUES IS_NUMERIC('0') |
|||
1 |
|||
------ |
|||
0 |
|||
1 record(s) selected. |
|||
VALUES IS_NUMERIC('-1') |
|||
1 |
|||
------ |
|||
0 |
|||
1 record(s) selected. |
|||
VALUES IS_NUMERIC('A') |
|||
1 |
|||
------ |
|||
1 |
|||
1 record(s) selected. |
|||
VALUES IS_NUMERIC('-') |
|||
1 |
|||
------ |
|||
1 |
|||
1 record(s) selected. |
|||
VALUES IS_NUMERIC('z') |
|||
1 |
|||
------ |
|||
1 |
|||
1 record(s) selected. |
|||
VALUES IS_NUMERIC('') |
|||
1 |
|||
------ |
|||
1 |
|||
1 record(s) selected. |
|||
VALUES IS_NUMERIC(' ') |
|||
1 |
|||
------ |
|||
1 |
|||
1 record(s) selected. |
|||
</pre> |
|||
=={{header|Standard ML}}== |
|||
<syntaxhighlight lang="sml">(* 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</syntaxhighlight> |
|||
=={{header|Swift}}== |
|||
{{works with|Swift|2.x+}} |
|||
<syntaxhighlight lang="swift">func isNumeric(a: String) -> Bool { |
|||
return Double(a) != nil |
|||
}</syntaxhighlight> |
|||
{{works with|Swift|1.x}} |
|||
This one only checks whether it is an integer: |
|||
<syntaxhighlight lang="swift">func isNumeric(a: String) -> Bool { |
|||
return a.toInt() != nil |
|||
}</syntaxhighlight> |
|||
=={{header|Tcl}}== |
=={{header|Tcl}}== |
||
<syntaxhighlight lang="tcl">proc isNumeric str {string is double -strict $str}</syntaxhighlight> |
|||
<lang tcl> |
|||
if { [string is double $varname] } then { ... } |
|||
</lang> |
|||
=={{header|TMG}}== |
|||
Also <tt>string is integer</tt> (, <tt>string is alnum</tt> etc etc) |
|||
Unix TMG dialect. NOTE: the program also performs some basic normalization (namely, removing the plus sign and translating "E" to "e"): |
|||
<syntaxhighlight lang="unixtmg">prog: ignore(<< >>) |
|||
parse(line)\prog |
|||
parse(error)\prog; |
|||
line: number *; |
|||
number: ignore(none) |
|||
sign float (exp | ={}) |
|||
= { < True: > 3 2 1 * }; |
|||
sign: <+>={} | <->={<->} | ={}; |
|||
float: int ( <.> decim = { 2 <.> 1 } | = { 1 } ) |
|||
| <.> int = { <.> 1 }; |
|||
int: smark any(digit) string(digit) scopy; |
|||
decim: smark string(digit) scopy; |
|||
exp: any(<<eE>>) sign int = { <e> 2 1 }; |
|||
error: smark any(nonl) ignore(none) string(nonl) scopy * = { <False: > 1 * }; |
|||
digit: <<0123456789>>; |
|||
none: <<>>; |
|||
nonl: !<< |
|||
>>;</syntaxhighlight> |
|||
Sample input: |
|||
<pre> |
|||
123 |
|||
+12345.678 |
|||
.678 |
|||
1. |
|||
+1.0E+99 |
|||
-7. |
|||
-123e-123 |
|||
00000 |
|||
. |
|||
1.2.3 |
|||
0x123 |
|||
a1-a5 |
|||
1 000 000 |
|||
1,000,000 |
|||
1.00e1e1 |
|||
</pre> |
|||
Sample output: |
|||
<pre> True: 123 |
|||
True: 12345.678 |
|||
True: .678 |
|||
True: 1. |
|||
True: 1.0e99 |
|||
True: -7. |
|||
True: -123e-123 |
|||
True: 00000 |
|||
False: . |
|||
False: 1.2.3 |
|||
False: 0x123 |
|||
False: a1-a5 |
|||
False: 1 000 000 |
|||
False: 1,000,000 |
|||
False: 1.00e1e1 |
|||
</pre> |
|||
=={{header|Toka}}== |
=={{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. |
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. |
||
<syntaxhighlight lang="toka">[ ( 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 ) |
|||
( Some tests ) |
|||
=={{header|VBScript}}== |
|||
decimal |
|||
IsNumeric(Expr) |
|||
" 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 )</syntaxhighlight> |
|||
Returns a True if numeric and a false if not. |
|||
=={{header| |
=={{header|True BASIC}}== |
||
{{trans|RapidQ}} |
|||
{{works with|Visual Basic|2005}} |
|||
<syntaxhighlight lang="basic"> |
|||
<lang vbnet> |
|||
DECLARE FUNCTION isnumeric$ |
|||
Dim Value As String = "+123" |
|||
LET true$ = "True" |
|||
If IsNumeric(Value) Then |
|||
LET false$ = "False" |
|||
PRINT "It is numeric." |
|||
LET s$ = "-152.34" |
|||
End If |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
</lang> |
|||
LET s$ = "1234.056789" |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
LET s$ = "1234.56" |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
LET s$ = "021101" |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
LET s$ = "Dog" |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
LET s$ = "Bad125" |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
LET s$ = "-0177" |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
LET s$ = "+123abcd.ef" |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
LET s$ = "54321" |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
LET s$ = "123xyz" |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
LET s$ = "xyz" |
|||
PRINT s$, " => "; isnumeric$(s$) |
|||
FUNCTION isnumeric$(s$) |
|||
LET optchar$ = "" |
|||
IF len(s$) = 0 then |
|||
LET isnumeric$ = false$ |
|||
EXIT FUNCTION |
|||
END IF |
|||
IF pos(s$,"+") > 1 then |
|||
LET isnumeric$ = false$ |
|||
EXIT FUNCTION |
|||
END IF |
|||
IF pos(s$,"-") > 1 then |
|||
LET isnumeric$ = false$ |
|||
EXIT FUNCTION |
|||
END IF |
|||
LET ndex = 0 |
|||
FOR i = 1 to len(s$) |
|||
SELECT CASE ord((s$)[i:i+1-1][1:1]) |
|||
CASE 43 !+ |
|||
CASE 45 !- |
|||
CASE 46 !. |
|||
IF ndex = 1 then |
|||
LET isnumeric$ = false$ |
|||
EXIT FUNCTION |
|||
END IF |
|||
LET ndex = 1 |
|||
CASE 48 to 57 !0 a 9 |
|||
CASE else |
|||
IF pos(optchar$,((s$)[i:i+1-1])) = 0 then |
|||
LET isnumeric$ = false$ |
|||
EXIT FUNCTION |
|||
END IF |
|||
END SELECT |
|||
NEXT i |
|||
LET isnumeric$ = true$ |
|||
END FUNCTION |
|||
END |
|||
</syntaxhighlight> |
|||
=={{header|UNIX Shell}}== |
|||
<syntaxhighlight lang="bash"> |
|||
#!/bin/bash |
|||
isnum() { |
|||
printf "%f" $1 >/dev/null 2>&1 |
|||
} |
|||
check() { |
|||
if isnum $1 |
|||
then |
|||
echo "$1 is numeric" |
|||
else |
|||
echo "$1 is NOT numeric" |
|||
fi |
|||
} |
|||
check 2 |
|||
check -3 |
|||
check +45.44 |
|||
check -33.332 |
|||
check 33.aa |
|||
check 3.3.3 |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
2 is numeric |
|||
-3 is numeric |
|||
+45.44 is numeric |
|||
-33.332 is numeric |
|||
33.aa is NOT numeric |
|||
3.3.3 is NOT numeric |
|||
</pre> |
|||
=={{header|Ursa}}== |
|||
<syntaxhighlight lang="ursa">def isnum (string str) |
|||
try |
|||
double str |
|||
return true |
|||
catch valueerror |
|||
return false |
|||
end try |
|||
end isnum</syntaxhighlight> |
|||
=={{header|VBA}}== |
|||
In France, IsNumeric("123.45") return False. |
|||
So we have to check the "." or "," and replace it by the Application.DecimalSeparator. |
|||
<syntaxhighlight lang="vb">Sub Main() |
|||
Debug.Print Is_Numeric("") |
|||
Debug.Print Is_Numeric("-5.32") |
|||
Debug.Print Is_Numeric("-51,321 32") |
|||
Debug.Print Is_Numeric("123.4") |
|||
Debug.Print Is_Numeric("123,4") |
|||
Debug.Print Is_Numeric("123;4") |
|||
Debug.Print Is_Numeric("123.4x") |
|||
End Sub |
|||
Private Function Is_Numeric(s As String) As Boolean |
|||
Dim Separat As String, Other As String |
|||
Separat = Application.DecimalSeparator |
|||
Other = IIf(Separat = ",", ".", ",") |
|||
Is_Numeric = IsNumeric(Replace(s, Other, Separat)) |
|||
End Function</syntaxhighlight> |
|||
=={{header|VBScript}}== |
|||
<syntaxhighlight lang="vb">IsNumeric(Expr)</syntaxhighlight> |
|||
Returns a True if numeric and a false if not. |
|||
=={{header|Vedit macro language}}== |
=={{header|Vedit macro language}}== |
||
Line 702: | Line 5,277: | ||
Only signed and unsigned integers are recognized, in decimal, hex (preceded with 0x) or octal (preceded with 0o). |
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. |
Remove the SUPPRESS option to evaluate an expression instead of single numeric value. |
||
<syntaxhighlight lang="vedit">:IS_NUMERIC: |
|||
<lang vedit> |
|||
:IS_NUMERIC: |
|||
if (Num_Eval(SUPPRESS)==0 && Cur_Char != '0') { |
if (Num_Eval(SUPPRESS)==0 && Cur_Char != '0') { |
||
Return(FALSE) |
Return(FALSE) |
||
} else { |
} else { |
||
Return(TRUE) |
Return(TRUE) |
||
}</syntaxhighlight> |
|||
=={{header|Visual Basic .NET}}== |
|||
{{works with|Visual Basic .NET|2005}} |
|||
<syntaxhighlight lang="vbnet">Dim Value As String = "+123" |
|||
If IsNumeric(Value) Then |
|||
PRINT "It is numeric." |
|||
End If</syntaxhighlight> |
|||
=={{header|V (Vlang)}}== |
|||
<syntaxhighlight lang="v (vlang)">import strconv |
|||
fn is_numeric(s string) bool { |
|||
strconv.atof64(s) or { |
|||
return false |
|||
} |
|||
return true |
|||
} |
} |
||
</lang> |
|||
fn main() { |
|||
println("Are these strings numeric?") |
|||
strings := ["1", "3.14", "-100", "1e2", "NaN", "rose", "0xff", "0b110"] |
|||
for s in strings { |
|||
println(" ${s:4} -> ${is_numeric(s)}") |
|||
} |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Are these strings numeric? |
|||
1 -> true |
|||
3.14 -> true |
|||
-100 -> true |
|||
1e2 -> true |
|||
NaN -> false |
|||
rose -> false |
|||
0xff -> true |
|||
0b110 -> true |
|||
</pre> |
|||
=={{header|Wren}}== |
|||
{{libheader|Wren-fmt}} |
|||
Wren's Num class already has a static method which does what this task requires. |
|||
<syntaxhighlight lang="wren">import "./fmt" for Fmt |
|||
System.print("Are these strings numeric?") |
|||
for (s in ["1", "3.14", "-100", "1e2", "NaN", "0xaf", "rose"]) { |
|||
var i = Num.fromString(s) // returns null if 's' is not numeric |
|||
System.print(" %(Fmt.s(4, s)) -> %((i != null) ? "yes" : "no")") |
|||
}</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Are these strings numeric? |
|||
1 -> yes |
|||
3.14 -> yes |
|||
-100 -> yes |
|||
1e2 -> yes |
|||
NaN -> yes |
|||
0xaf -> yes |
|||
rose -> no |
|||
</pre> |
|||
=={{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'. |
|||
<syntaxhighlight lang="xlisp">(DEFUN NUMERICP (X) |
|||
(IF (STRING->NUMBER X) T))</syntaxhighlight> |
|||
=={{header|XPL0}}== |
|||
The compiler is more strict in the characters it accepts as numeric than |
|||
what is accepted here. This program indicates more of what the input |
|||
intrinsics (IntIn, RlIn and HexIn) would accept as numeric. |
|||
<syntaxhighlight lang "XPL0">string 0; |
|||
func IsNumeric(Str); |
|||
char Str; |
|||
[while Str(0) # 0 do |
|||
[if Str(0) >= ^0 and Str(0) <= ^9 then return true; |
|||
if Str(0) = ^$ then |
|||
[if Str(1) >= ^0 and Str(1) <= ^9 then return true; |
|||
if Str(1) >= ^A and Str(1) <= ^F then return true; |
|||
if Str(1) >= ^a and Str(1) <= ^f then return true; |
|||
]; |
|||
Str:= Str+1; |
|||
]; |
|||
return false; |
|||
]; |
|||
int Strs, S; |
|||
[Text(0, "Are these strings numeric?^m^j"); |
|||
Strs:= ["1", "3.14", "-100", "1e2", "NaN", "$af", "%1_1011", "rose", ". 3", "num9", "x$ 9", "x$ a"]; |
|||
for S:= 0 to 12-1 do |
|||
[Text(0, if IsNumeric(Strs(S)) then "yes : " else "no : "); |
|||
Text(0, Strs(S)); |
|||
CrLf(0); |
|||
]; |
|||
]</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Are these strings numeric? |
|||
yes : 1 |
|||
yes : 3.14 |
|||
yes : -100 |
|||
yes : 1e2 |
|||
no : NaN |
|||
yes : $af |
|||
yes : %1_1011 |
|||
no : rose |
|||
yes : . 3 |
|||
yes : num9 |
|||
yes : x$ 9 |
|||
no : x$ a |
|||
</pre> |
|||
=={{header|Z80 Assembly}}== |
|||
{{works with|CP/M 3.1|YAZE-AG-2.51.2 Z80 emulator}} |
|||
{{works with|ZSM4 macro assembler|YAZE-AG-2.51.2 Z80 emulator}} |
|||
Use the /S8 switch on the ZSM4 assembler for 8 significant characters for labels and names |
|||
<syntaxhighlight lang="z80"> |
|||
; |
|||
; Check if input string is a number using Z80 assembly language |
|||
; |
|||
; Runs under CP/M 3.1 on YAZE-AG-2.51.2 Z80 emulator |
|||
; Assembled with zsm4 on same emulator/OS, uses macro capabilities of said assembler |
|||
; Created with vim under Windows |
|||
; |
|||
; 2023-04-04 Xorph |
|||
; |
|||
; |
|||
; Useful definitions |
|||
; |
|||
bdos equ 05h ; Call to CP/M BDOS function |
|||
strdel equ 6eh ; Set string delimiter |
|||
readstr equ 0ah ; Read string from console |
|||
wrtstr equ 09h ; Write string to console |
|||
nul equ 00h ; ASCII control characters |
|||
esc equ 1bh |
|||
cr equ 0dh |
|||
lf equ 0ah |
|||
cnull equ '0' ; ASCII character constants |
|||
cnine equ '9' |
|||
cminus equ '-' |
|||
cdot equ '.' |
|||
buflen equ 30h ; Length of input buffer |
|||
minbit equ 00h ; Bit 0 is used as flag for '-' |
|||
dotbit equ 01h ; Bit 1 is used as flag for '.' |
|||
; |
|||
; Macros for BDOS calls |
|||
; |
|||
setdel macro char ; Set string delimiter to char |
|||
ld c,strdel |
|||
ld e,char |
|||
call bdos |
|||
endm |
|||
print macro msg ; Output string to console |
|||
ld c,wrtstr |
|||
ld de,msg |
|||
call bdos |
|||
endm |
|||
newline macro ; Print newline |
|||
ld c,wrtstr |
|||
ld de,crlf |
|||
call bdos |
|||
endm |
|||
readln macro buf ; Read a line from input |
|||
ld c,readstr |
|||
ld de,buf |
|||
call bdos |
|||
endm |
|||
; |
|||
; ===================== |
|||
; Start of main program |
|||
; ===================== |
|||
; |
|||
cseg |
|||
isnum: |
|||
setdel nul ; Set string terminator to nul ('\0') - '$' is default in CP/M |
|||
print help |
|||
newline |
|||
newline |
|||
readnum: |
|||
ld b,buflen ; Clear input buffer |
|||
ld hl,bufcont |
|||
clrloop: |
|||
ld (hl),0 |
|||
inc hl |
|||
djnz clrloop |
|||
readln inputbuf ; Read a line from input |
|||
newline ; Newline is discarded during input, so write one... |
|||
ld a,(inputbuf+1) ; Length of actual input |
|||
cp 0 ; If empty input, quit |
|||
ret z |
|||
ld b,a ; Loop counter for djnz instruction |
|||
ld c,0 ; Use c for flags: '-' and '.' may be encountered at most once, '-' only at start |
|||
ld hl,bufcont ; Start of actual input |
|||
loop: |
|||
ld a,(hl) ; Get next character into a |
|||
cp cminus ; Check minus sign |
|||
jr z,chkminus |
|||
cp cdot ; Check dot |
|||
jr z,chkdot |
|||
cp cnull ; Check if below '0' |
|||
jr c,notanum |
|||
cp cnine+1 ; Check if above '9' |
|||
jr nc,notanum |
|||
checknxt: |
|||
set minbit,c ; Whatever the case, no more '-' are allowed after the first character |
|||
inc hl ; Increase hl to next character and repeat until done |
|||
djnz loop |
|||
print bufcont ; If we made it this far, we are done and the string is numeric |
|||
print yesmsg |
|||
newline |
|||
newline |
|||
done: |
|||
jp readnum ; Read next input from user until terminated with ^C or empty input |
|||
ret ; Return to CP/M (unreachable code) |
|||
notanum: |
|||
print bufcont ; Print failure message |
|||
print nomsg |
|||
newline |
|||
newline |
|||
jr done |
|||
chkminus: |
|||
bit minbit,c ; If a '-' is encountered and the flag is already set, the string is not numeric |
|||
jr nz,notanum |
|||
set minbit,c ; Otherwise, set flag and check next character |
|||
jr checknxt |
|||
chkdot: |
|||
bit dotbit,c ; If a '.' is encountered and the flag is already set, the string is not numeric |
|||
jr nz,notanum |
|||
set dotbit,c ; Otherwise, set flag and check next character |
|||
jr checknxt |
|||
; |
|||
; =================== |
|||
; End of main program |
|||
; =================== |
|||
; |
|||
; |
|||
; ================ |
|||
; Data definitions |
|||
; ================ |
|||
; |
|||
dseg |
|||
help: |
|||
defz 'Enter numbers to check, end with empty line or ^C' |
|||
inputbuf: ; Input buffer for CP/M BDOS call |
|||
defb buflen ; Maximum possible length |
|||
defb 00h ; Returned length of actual input |
|||
bufcont: |
|||
defs buflen ; Actual input area |
|||
defb nul ; Null terminator for output, if buffer is filled completely |
|||
yesmsg: |
|||
defz ' is numeric' |
|||
nomsg: |
|||
defz ' is not numeric' |
|||
crlf: defb cr,lf,nul ; Generic newline |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
E>isnum |
|||
Enter numbers to check, end with empty line or ^C |
|||
1234 |
|||
1234 is numeric |
|||
hello |
|||
hello is not numeric |
|||
12.34 |
|||
12.34 is numeric |
|||
-98.76 |
|||
-98.76 is numeric |
|||
4.6.76 |
|||
4.6.76 is not numeric |
|||
34-56-23 |
|||
34-56-23 is not numeric |
|||
-.9876543210 |
|||
-.9876543210 is numeric |
|||
444555. |
|||
444555. is numeric |
|||
1234c |
|||
1234c is not numeric |
|||
123e45 |
|||
123e45 is not numeric |
|||
</pre> |
|||
=={{header|Zig}}== |
|||
<syntaxhighlight lang="zig"> |
|||
const std = @import("std"); |
|||
const stdout = std.io.getStdOut().writer(); |
|||
fn isNumeric(str: []const u8) bool { |
|||
const num = std.mem.trim(u8, str, "\x20"); |
|||
_ = std.fmt.parseFloat(f64, num) catch return false; |
|||
return true; |
|||
} |
|||
pub fn main() !void { |
|||
const s1 = " 123"; |
|||
const s2 = " +123"; |
|||
const s3 = " 12.3"; |
|||
const s4 = "-12.3"; |
|||
const s5 = "12e-3"; |
|||
const s6 = "=12-3"; |
|||
const s7 = "abcde"; |
|||
const s8 = "12cde"; |
|||
const s9 = "NaN"; |
|||
const s10 = "0xFF"; |
|||
try stdout.print("Is {s} numeric? {}\n", .{ s1, isNumeric(s1) }); |
|||
try stdout.print("Is {s} numeric? {}\n", .{ s2, isNumeric(s2) }); |
|||
try stdout.print("Is {s} numeric? {}\n", .{ s3, isNumeric(s3) }); |
|||
try stdout.print("Is {s} numeric? {}\n", .{ s4, isNumeric(s4) }); |
|||
try stdout.print("Is {s} numeric? {}\n", .{ s5, isNumeric(s5) }); |
|||
try stdout.print("Is {s} numeric? {}\n", .{ s6, isNumeric(s6) }); |
|||
try stdout.print("Is {s} numeric? {}\n", .{ s7, isNumeric(s7) }); |
|||
try stdout.print("Is {s} numeric? {}\n", .{ s8, isNumeric(s8) }); |
|||
try stdout.print("Is {s} numeric? {}\n", .{ s9, isNumeric(s9) }); |
|||
try stdout.print("Is {s} numeric? {}\n", .{ s10, isNumeric(s10) }); |
|||
} |
|||
</syntaxhighlight> |
|||
{{out}} |
|||
<pre> |
|||
Is 123 numeric? true |
|||
Is +123 numeric? true |
|||
Is 12.3 numeric? true |
|||
Is -12.3 numeric? true |
|||
Is 12e-3 numeric? true |
|||
Is =12-3 numeric? false |
|||
Is abcde numeric? false |
|||
Is 12cde numeric? false |
|||
Is NaN numeric? true |
|||
Is 0xFF numeric? true |
|||
</pre> |
|||
=={{header|zkl}}== |
|||
<syntaxhighlight lang="zkl">fcn isNum(text){ |
|||
try{ text.toInt(); True } |
|||
catch{ try{ text.toFloat(); True } |
|||
catch{ False } |
|||
} |
|||
}</syntaxhighlight> |
|||
<pre> |
|||
isNum("123.4") //-->True |
|||
isNum("123") //-->True |
|||
isNum("-123.4") //-->True |
|||
isNum("123.4x") //-->False |
|||
isNum("hoho") //-->False |
|||
isNum(123.4) //-->True |
|||
isNum(123) //-->True |
|||
</pre> |
|||
=={{header|Zoea}}== |
|||
<syntaxhighlight lang="zoea"> |
|||
program: numeric |
|||
case: 1 input: '1' output: true |
|||
case: 2 input: '-3' output: true |
|||
case: 3 input: '22.7' output: true |
|||
case: 4 input: 'a' output: false |
|||
case: 5 input: 'Fred' output: false |
|||
case: 6 input: '' output: false |
|||
</syntaxhighlight> |
|||
=={{header|Zoea Visual}}== |
|||
[http://zoea.co.uk/examples/zv-rc/Numeric.png Determine if string is numeric] |
|||
{{omit from|GUISS}} |
|||
[[Category: String manipulation]] |
Latest revision as of 17:40, 28 June 2024
You are encouraged to solve this task according to the task description, using any language you may know.
- 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.
- Metrics
- Counting
- Word frequency
- Letter frequency
- Jewels and stones
- I before E except after C
- Bioinformatics/base count
- Count occurrences of a substring
- Count how many vowels and consonants occur in a string
- Remove/replace
- XXXX redacted
- Conjugate a Latin verb
- Remove vowels from a string
- String interpolation (included)
- Strip block comments
- Strip comments from a string
- Strip a set of characters from a string
- Strip whitespace from a string -- top and tail
- Strip control codes and extended characters from a string
- Anagrams/Derangements/shuffling
- Word wheel
- ABC problem
- Sattolo cycle
- Knuth shuffle
- Ordered words
- Superpermutation minimisation
- Textonyms (using a phone text pad)
- Anagrams
- Anagrams/Deranged anagrams
- Permutations/Derangements
- Find/Search/Determine
- ABC words
- Odd words
- Word ladder
- Semordnilap
- Word search
- Wordiff (game)
- String matching
- Tea cup rim text
- Alternade words
- Changeable words
- State name puzzle
- String comparison
- Unique characters
- Unique characters in each string
- Extract file extension
- Levenshtein distance
- Palindrome detection
- Common list elements
- Longest common suffix
- Longest common prefix
- Compare a list of strings
- Longest common substring
- Find common directory path
- Words from neighbour ones
- Change e letters to i in words
- Non-continuous subsequences
- Longest common subsequence
- Longest palindromic substrings
- Longest increasing subsequence
- Words containing "the" substring
- Sum of the digits of n is substring of n
- Determine if a string is numeric
- Determine if a string is collapsible
- Determine if a string is squeezable
- Determine if a string has all unique characters
- Determine if a string has all the same characters
- Longest substrings without repeating characters
- Find words which contains all the vowels
- Find words which contain the most consonants
- Find words which contains more than 3 vowels
- Find words whose first and last three letters are equal
- Find words with alternating vowels and consonants
- Formatting
- Substring
- Rep-string
- Word wrap
- String case
- Align columns
- Literals/String
- Repeat a string
- Brace expansion
- Brace expansion using ranges
- Reverse a string
- Phrase reversals
- Comma quibbling
- Special characters
- String concatenation
- Substring/Top and tail
- Commatizing numbers
- Reverse words in a string
- Suffixation of decimal numbers
- Long literals, with continuations
- Numerical and alphabetical suffixes
- Abbreviations, easy
- Abbreviations, simple
- Abbreviations, automatic
- Song lyrics/poems/Mad Libs/phrases
- Mad Libs
- Magic 8-ball
- 99 bottles of beer
- The Name Game (a song)
- The Old lady swallowed a fly
- The Twelve Days of Christmas
- Tokenize
- Text between
- Tokenize a string
- Word break problem
- Tokenize a string with escaping
- Split a character string based on change of character
- Sequences
6502 Assembly
For this program, a valid numeric string literal consists of only numbers (ascii $30-$39), up to one leading minus sign, and no more than one decimal point. Anything else, including the null string, is considered non-numeric.
Macros used (VASM syntax):
macro loadpair,regs,addr lda #<\addr sta \regs lda #>\addr sta \regs+1 endm macro pushY tya pha endm macro popY pla tay endm
The code:
*=$0801
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
lda #$0e
jsr chrout ;required for my printing routine to work.
z_HL equ $02
z_L equ $02
z_H equ $03
z_B equ $04
loadpair z_HL,TestString0
jsr isStringNumeric
loadpair z_HL,TestString1
jsr isStringNumeric
loadpair z_HL,TestString2
jsr isStringNumeric
loadpair z_HL,TestString3
jsr isStringNumeric
loadpair z_HL,TestString4
jsr isStringNumeric
loadpair z_HL,TestString5
jsr isStringNumeric
loadpair z_HL,TestString6
jsr isStringNumeric
loadpair z_HL,TestString7
jsr isStringNumeric
loadpair z_HL,TestString8
jsr isStringNumeric
rts ;return to basic
isStringNumeric:
; input: z_HL = source address
pushY
ldy #0
sty z_B ;our tally for decimal points
checkFirstChar:
lda (z_HL),y
beq notNumeric ;a null string is not a valid number!
cmp #'-'
beq isNegative_OK
cmp #'.'
beq isFloat_OK
and #$30
cmp #$30
beq isNumeral_OK
;else, is not numeric
notNumeric:
popY
jsr PrintString_TextScreen ;prints what's already in z_HL
jsr NewLine
loadpair z_HL,isStringNumeric_Fail
jsr PrintString_TextScreen
jsr NewLine
jmp NewLine
;rts
isNegative_OK:
isNumeral_OK:
iny
jmp loop_isStringNumeric
isFloat_OK:
iny
inc z_B
loop_isStringNumeric:
lda (z_HL),y
beq Terminated_isStringNumeric
cmp #'.'
beq CheckIfDecimalAlreadyOccurred
and #$30
cmp #$30
bne notNumeric
loop_overhead_isStringNumeric:
iny
jmp loop_isStringNumeric
CheckIfDecimalAlreadyOccurred:
lda z_B
bne notNumeric
inc z_B
jmp loop_overhead_isStringNumeric
Terminated_isStringNumeric:
;if we got this far the string is numeric.
popY
jsr PrintString_TextScreen ;prints what's already in z_HL
jsr NewLine
loadpair z_HL,isStringNumeric_Pass
jsr PrintString_TextScreen
jsr NewLine
jmp NewLine
;rts
isStringNumeric_Pass:
db "IS NUMERIC",0
isStringNumeric_Fail:
db "IS NOT NUMERIC",0
TestString0:
db 0
TestString1:
db "123",0
TestString2:
db "-30",0
TestString3:
db "123.45",0
TestString4:
db "-123.45",0
TestString5:
db "ABCDE",0
TestString6:
db "-34-5",0
TestString7:
db "1.000.000",0
TestString8:
db ".23456",0
- Output:
ready. load"*",8,1: searching for * loading ready. run IS NOT NUMERIC 123 IS NUMERIC -30 IS NUMERIC 123.45 IS NUMERIC -123.45 IS NUMERIC ABCDE IS NOT NUMERIC -34-5 IS NOT NUMERIC 1.000.000 IS NOT NUMERIC .23456 IS NUMERIC ready.
8th
: number? >n >kind ns:n n:= ;
AArch64 Assembly
/* ARM assembly Raspberry PI */
/* program strNumber.s */
/*******************************************/
/* Constantes file */
/*******************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ BUFFERSIZE, 100
/* Initialized data */
.data
szMessNum: .asciz "Enter number : \n"
szMessError: .asciz "String is not a number !!!\n"
szMessInteger: .asciz "String is a integer.\n"
szMessFloat: .asciz "String is a float.\n"
szMessFloatExp: .asciz "String is a float with exposant.\n"
szCarriageReturn: .asciz "\n"
/* UnInitialized data */
.bss
sBuffer: .skip BUFFERSIZE
/* code section */
.text
.global main
main:
loop:
ldr x0,qAdrszMessNum
bl affichageMess
mov x0,#STDIN // Linux input console
ldr x1,qAdrsBuffer // buffer address
mov x2,#BUFFERSIZE // buffer size
mov x8, #READ // request to read datas
svc 0 // call system
ldr x1,qAdrsBuffer // buffer address
mov x2,#0 // end of string
sub x0,x0,#1 // replace character 0xA
strb w2,[x1,x0] // store byte at the end of input string (x0 contains number of characters)
ldr x0,qAdrsBuffer
bl controlNumber // call routine
cmp x0,#0
bne 1f
ldr x0,qAdrszMessError // not a number
bl affichageMess
b 5f
1:
cmp x0,#1
bne 2f
ldr x0,qAdrszMessInteger // integer
bl affichageMess
b 5f
2:
cmp x0,#2
bne 3f
ldr x0,qAdrszMessFloat // float
bl affichageMess
b 5f
3:
cmp x0,#3
bne 5f
ldr x0,qAdrszMessFloatExp // float with exposant
bl affichageMess
5:
b loop
100: // standard end of the program
mov x0, #0 // return code
mov x8, #EXIT // request to exit program
svc 0 // perform system call
qAdrszMessNum: .quad szMessNum
qAdrszMessError: .quad szMessError
qAdrszMessInteger: .quad szMessInteger
qAdrszMessFloat: .quad szMessFloat
qAdrszMessFloatExp: .quad szMessFloatExp
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrsBuffer: .quad sBuffer
/******************************************************************/
/* control if string is number */
/******************************************************************/
/* x0 contains the address of the string */
/* x0 return 0 if not a number */
/* x0 return 1 if integer eq 12345 or -12345 */
/* x0 return 2 if float eq 123.45 or 123,45 or -123,45 */
/* x0 return 3 if float with exposant eq 123.45E30 or -123,45E-30 */
controlNumber:
stp x1,lr,[sp,-16]! // save registers
stp x2,x3,[sp,-16]! // save registers
stp x4,x5,[sp,-16]! // save registers
mov x1,#0
mov x3,#0 // point counter
1:
ldrb w2,[x0,x1]
cmp x2,#0 // end string ?
beq 7f
cmp x2,#' ' // space ?
bne 3f
add x1,x1,#1
b 1b // loop
3:
cmp x2,#'-' // negative ?
bne 4f
add x1,x1,#1
b 5f
4:
cmp x2,#'+' // positive ?
bne 5f
add x1,x1,#1
5:
ldrb w2,[x0,x1] // control space
cmp x2,#0 // end ?
beq 7f
cmp x2,#' ' // space ?
bne 6f
add x1,x1,#1
b 5b // loop
6:
ldrb w2,[x0,x1]
cmp x2,#0 // end ?
beq 14f
cmp x2,#'E' // exposant ?
beq 9f
cmp x2,#'e' // exposant ?
beq 9f
cmp x2,#'.' // point ?
bne 7f
add x3,x3,#1 // yes increment counter
add x1,x1,#1
b 6b // and loop
7:
cmp x2,#',' // comma ?
bne 8f
add x3,x3,#1 // yes increment counter
add x1,x1,#1
b 6b // and loop
8:
cmp x2,#'0' // control digit < 0
blt 99f
cmp x2,#'9' // control digit > 0
bgt 99f
add x1,x1,#1 // no error loop digit
b 6b
9: // float with exposant
add x1,x1,#1
ldrb w2,[x0,x1]
cmp x2,#0 // end ?
beq 99f
cmp x2,#'-' // negative exposant ?
bne 10f
add x1,x1,#1
10:
mov x4,#0 // nombre de chiffres
11:
ldrb w2,[x0,x1]
cmp x2,#0 // end ?
beq 13f
cmp x2,#'0' // control digit < 0
blt 99f
cmp x2,#'9' // control digit > 9
bgt 99f
add x1,x1,#1
add x4,x4,#1 // counter digit
b 11b // and loop
13:
cmp x4,#0 // number digit exposant = 0 -> error
beq 99f // error
cmp x4,#2 // number digit exposant > 2 -> error
bgt 99f // error
mov x0,#3 // valid float with exposant
b 100f
14:
cmp x3,#0
bne 15f
mov x0,#1 // valid integer
b 100f
15:
cmp x3,#1 // number of point or comma = 1 ?
blt 100f
bgt 99f // error
mov x0,#2 // valid float
b 100f
99:
mov x0,#0 // error
100:
ldp x4,x5,[sp],16 // restaur 2 registres
ldp x2,x3,[sp],16 // restaur 2 registres
ldp x1,lr,[sp],16 // restaur 2 registres
ret
/********************************************************/
/* File Include fonctions */
/********************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
Action!
Using string <-> number conversion
The solution below uses conversion string to number and number to string to determine if the string is numeric.
INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit
BYTE FUNC AreEqual(CHAR ARRAY a,b)
BYTE i
IF a(0)#b(0) THEN
RETURN (0)
FI
FOR i=1 to a(0)
DO
IF a(i)#b(i) THEN
RETURN (0)
FI
OD
RETURN (1)
BYTE FUNC IsNumeric(CHAR ARRAY s)
CHAR ARRAY tmp(20)
INT i
CARD c
REAL r
i=ValI(s)
StrI(i,tmp)
IF AreEqual(s,tmp) THEN
RETURN (1)
FI
c=ValC(s)
StrC(c,tmp)
IF AreEqual(s,tmp) THEN
RETURN (1)
FI
ValR(s,r)
StrR(r,tmp)
IF AreEqual(s,tmp) THEN
RETURN (1)
FI
RETURN (0)
PROC Test(CHAR ARRAY s)
BYTE res
res=IsNumeric(s)
Print(s)
Print(" is ")
IF res=0 THEN
Print("not ")
FI
PrintE("a number.")
RETURN
PROC Main()
Put(125) PutE() ;clear the screen
Test("56233")
Test("-315")
Test("1.36")
Test("-5.126")
Test("3.7E-05")
Test("1.23BC")
Test("5.6.3")
RETURN
Using a finite-state machine
The solution below uses a finite-state machine to determine if a string is numeric.
BYTE FUNC IsSign(CHAR c)
IF c='- OR c='+ THEN
RETURN (1)
FI
RETURN (0)
BYTE FUNC IsDigit(CHAR c)
IF c>='0 AND c<='9 THEN
RETURN (1)
FI
RETURN (0)
BYTE FUNC IsDot(CHAR c)
IF c='. THEN
RETURN (1)
FI
RETURN (0)
BYTE FUNC IsExpSymbol(CHAR c)
IF c='E OR c='e THEN
RETURN (1)
FI
RETURN (0)
BYTE FUNC IsNumeric(CHAR ARRAY s)
DEFINE S_BEGIN="0"
DEFINE S_SIGN="1"
DEFINE S_BEFORE_DOT="2"
DEFINE S_DOT="3"
DEFINE S_AFTER_DOT="4"
DEFINE S_EXP_SYMBOL="5"
DEFINE S_EXP_SIGN="6"
DEFINE S_EXP="7"
BYTE i,state
CHAR c
i=1
state=S_BEGIN
WHILE i<=s(0)
DO
c=s(i)
IF state=S_BEGIN THEN
IF IsSign(c) THEN
state=S_SIGN
ELSEIF IsDigit(c) THEN
state=S_BEFORE_DOT
ELSEIF IsDot(c) THEN
state=S_DOT
ELSE
RETURN (0)
FI
ELSEIF state=S_SIGN THEN
IF IsDigit(c) THEN
state=S_BEFORE_DOT
ELSEIF IsDot(c) THEN
state=S_DOT
ELSE
RETURN (0)
FI
ELSEIF state=S_BEFORE_DOT THEN
IF IsDigit(c) THEN
state=S_BEFORE_DOT
ELSEIF IsDot(c) THEN
state=S_DOT
ELSEIF IsExpSymbol(c) THEN
state=S_EXP_SYMBOL
ELSE
RETURN (0)
FI
ELSEIF state=S_DOT THEN
IF IsDigit(c) THEN
state=S_AFTER_DOT
ELSEIF IsExpSymbol(c) THEN
state=S_EXP_SYMBOL
ELSE
RETURN (0)
FI
ELSEIF state=S_AFTER_DOT THEN
IF IsDigit(c) THEN
state=S_AFTER_DOT
ELSEIF IsExpSymbol(c) THEN
state=S_EXP_SYMBOL
ELSE
RETURN (0)
FI
ELSEIF state=S_EXP_SYMBOL THEN
IF IsSign(c) THEN
state=S_EXP_SIGN
ELSEIF IsDigit(c) THEN
state=S_EXP
ELSE
RETURN (0)
FI
ELSEIF state=S_EXP_SIGN THEN
IF IsDigit(c) THEN
state=S_EXP
ELSE
RETURN (0)
FI
ELSEIF state=S_EXP THEN
IF IsDigit(c) THEN
state=S_EXP
ELSE
RETURN (0)
FI
ELSE
RETURN (0)
FI
i==+1
OD
IF state=S_BEGIN OR state=S_DOT OR
state=S_EXP_SIGN OR state=S_EXP_SIGN THEN
RETURN (0)
FI
RETURN (1)
PROC Test(CHAR ARRAY s)
BYTE res
res=IsNumeric(s)
Print(s)
Print(" is ")
IF res=0 THEN
Print("not ")
FI
PrintE("a number.")
RETURN
PROC Main()
Test("56233")
Test("-315")
Test("1.36")
Test("-5.126")
Test("3.7E-05")
Test("1.23BC")
Test("5.6.3")
RETURN
- Output:
Screenshot from Atari 8-bit computer
56233 is a number. -315 is a number. 1.36 is a number. -5.126 is a number. 3.7E-05 is a number. 1.23BC is not a number. 5.6.3 is not a number.
ActionScript
public function isNumeric(num:String):Boolean
{
return !isNaN(parseInt(num));
}
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
function Is_Numeric (Item : in String) return Boolean is
Dummy : Float;
begin
Dummy := Float'Value (Item);
return True;
exception
when others =>
return False;
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 Is_Numeric_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 Is_Numeric_Test;
- Output:
152 results in TRUE -3.1415926 results in TRUE Foo123 results in FALSE
Aime
integer
is_numeric(text s)
{
return !trap_q(alpha, s, 0);
}
integer
main(void)
{
if (!is_numeric("8192&*")) {
o_text("Not numeric.\n");
}
if (is_numeric("8192")) {
o_text("Numeric.\n");
}
return 0;
}
ALGOL 68
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
ALGOL W
begin
% determnines whether the string contains an integer, real or imaginary %
% number. Returns true if it does, false otherwise %
logical procedure isNumeric( string(32) value text ) ;
begin
logical ok;
% the "number" cannot be blank %
ok := ( text not = " " );
if ok then begin
% there is at least one non-blank character %
% must have either an integer or real/immaginary number %
% integer: [+|-]digit-sequence %
% real: [+|-][digit-sequence].digit-sequence['integer][L] %
% or: [+|-]digit-sequence[.[digit-sequence]]'integer[L] %
% imaginary: %
% [+|-][digit-sequence].digit-sequence['integer][L]I%
% or: [+|-]digit-sequence[.[digit-sequence]]'integer[L]I%
% The "I" at the end of an imaginary number can appear %
% before or after the "L" (which indicates a long number) %
% the "I" and "L" can be in either case %
procedure nextChar ; charPos := charPos + 1;
logical procedure have( string(1) value ch ) ;
( charPos <= maxChar and text(charPos//1) = ch ) ;
logical procedure haveDigit ;
( charPos <= maxChar and text(charPos//1) >= "0" and text(charPos//1) <= "9" ) ;
integer charPos, maxChar;
logical hadDigits, isReal;
charPos := 0;
maxChar := 31;
hadDigits := false;
isReal := false;
% skip trailing spaces %
while maxChar > 0 and text(maxChar//1) = " " do maxChar := maxChar - 1;
% skip leading spacesx %
while have( " " ) do nextChar;
% skip optional sign %
if have( "+" ) or have( "-" ) then nextChar;
if haveDigit then begin
% have a digit sequence %
hadDigits := true;
while haveDigit do nextChar
end if_have_sign ;
if have( "." ) then begin
% real or imaginary number %
nextChar;
isReal := true;
hadDigits := hadDigits or haveDigit;
while haveDigit do nextChar
end if_have_point ;
% should have had some digits %
ok := hadDigits;
if ok and have( "'" ) then begin
% the number has an exponent %
isReal := true;
nextChar;
% skip optional sign %
if have( "+" ) or have( "-" ) then nextChar;
% must have a digit sequence %
ok := haveDigit;
while haveDigit do nextChar;
end if_ok_and_have_exponent ;
% if it is a real number, there could be L/I suffixes %
if ok and isReal then begin
integer LCount, ICount;
LCount := 0;
ICount := 0;
while have( "L" ) or have( "l" ) or have( "I" ) or have( "i" ) do begin
if have( "L" ) or have( "l" )
then LCount := LCount + 1
else ICount := ICount + 1;
nextChar
end while_have_L_or_I ;
% there can be at most one L and at most 1 I %
ok := ( LCount < 2 and ICount < 2 )
end if_ok_and_isReal ;
% must now be at the end if the number %
ok := ok and charPos >= maxChar
end if_ok ;
ok
end isNumeric ;
% test the isNumeric procedure %
procedure testIsNumeric( string(32) value n
; logical value expectedResult
) ;
begin
logical actualResult;
actualResult := isNumeric( n );
write( s_w := 0
, """", n, """ is "
, if actualResult then "" else "not "
, "numeric "
, if actualResult = expectedResult then "" else " NOT "
, "as expected"
)
end testIsNumeric ;
testIsNumeric( "", false );
testIsNumeric( "b", false );
testIsNumeric( ".", false );
testIsNumeric( ".'3", false );
testIsNumeric( "3.'", false );
testIsNumeric( "0.0z44", false );
testIsNumeric( "-1IL", false );
testIsNumeric( "4.5'23ILL", false );
write( "---------" );
testIsNumeric( "-1", true );
testIsNumeric( " +.345", true );
testIsNumeric( "4.5'23I", true );
testIsNumeric( "-5'+3i", true );
testIsNumeric( "-5'-3l", true );
testIsNumeric( " -.345LI", true );
end.
- Output:
" " is not numeric as expected "b " is not numeric as expected ". " is not numeric as expected ".'3 " is not numeric as expected "3.' " is not numeric as expected "0.0z44 " is not numeric as expected "-1IL " is not numeric as expected "4.5'23ILL " is not numeric as expected --------- "-1 " is numeric as expected " +.345 " is numeric as expected "4.5'23I " is numeric as expected "-5'+3i " is numeric as expected "-5'-3l " is numeric as expected " -.345LI " is numeric as expected
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';
String decimalString = '123.456';
System.debug(numericString.isNumeric()); // this will be true
System.debug(partlyNumericString.isNumeric()); // this will be false
System.debug(decimalString.isNumeric()); // this will be false
System.debug(decimalString.remove('.').isNumeric()); // this will be true
APL
⊃⎕VFI{w←⍵⋄((w='-')/w)←'¯'⋄w}'152 -3.1415926 Foo123'
1 1 0
Works with more recent versions of Dyalog APL
⊃⎕VFI '¯' @ ('-'∘=) '152 -3.1415926 Foo123' ⍝ Fast: replacement of - with APL high-minus required for ⎕VFI
1 1 0
⊃⎕VFI '-' ⎕R '¯' ⊣ '152 -3.1415926 Foo123' ⍝ Simple: (ditto)
1 1 0
{∧/⍵∊(⊃,¨'0123456789¯.+')}¨'152' '¯3.1415926' 'Foo123'
1 1 0
AppleScript
-- isNumString :: String -> Bool
on isNumString(s)
try
if class of s is string then
set c to class of (s as number)
c is real or c is integer
else
false
end if
on error
false
end try
end isNumString
-- TEST
on run
map(isNumString, {3, 3.0, 3.5, "3.5", "3E8", "-3.5", "30", "three", three, four})
--> {false, false, false, true, true, true, true, false, false, false}
end run
-- three :: () -> Int
script three
3
end script
-- four :: () -> Int
on four()
4
end four
-- GENERIC FUNCTIONS FOR TEST
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to lambda(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property lambda : f
end script
end if
end mReturn
- Output:
{false, false, false, true, true, true, true, false, false, false}
The classic way's slightly simpler, since the coercion result must be a real or an integer if the coercion itself didn't error.
on isNumString(s)
if (s's class is not text) then return false
try
s as number
return true
on error
return false
end try
end isNumString
ARM Assembly
/* ARM assembly Raspberry PI */
/* program strNumber.s */
/* Constantes */
.equ STDIN, 0 @ Linux input console
.equ STDOUT, 1 @ Linux output console
.equ EXIT, 1 @ Linux syscall
.equ READ, 3 @ Linux syscall
.equ WRITE, 4 @ Linux syscall
.equ BUFFERSIZE, 100
/* Initialized data */
.data
szMessNum: .asciz "Enter number : \n"
szMessError: .asciz "String is not a number !!!\n"
szMessInteger: .asciz "String is a integer.\n"
szMessFloat: .asciz "String is a float.\n"
szMessFloatExp: .asciz "String is a float with exposant.\n"
szCarriageReturn: .asciz "\n"
/* UnInitialized data */
.bss
sBuffer: .skip BUFFERSIZE
/* code section */
.text
.global main
main:
loop:
ldr r0,iAdrszMessNum
bl affichageMess
mov r0,#STDIN @ Linux input console
ldr r1,iAdrsBuffer @ buffer address
mov r2,#BUFFERSIZE @ buffer size
mov r7, #READ @ request to read datas
swi 0 @ call system
ldr r1,iAdrsBuffer @ buffer address
mov r2,#0 @ end of string
sub r0,#1 @ replace character 0xA
strb r2,[r1,r0] @ store byte at the end of input string (r0 contains number of characters)
ldr r0,iAdrsBuffer
bl controlNumber @ call routine
cmp r0,#0
bne 1f
ldr r0,iAdrszMessError @ not a number
bl affichageMess
b 5f
1:
cmp r0,#1
bne 2f
ldr r0,iAdrszMessInteger @ integer
bl affichageMess
b 5f
2:
cmp r0,#2
bne 3f
ldr r0,iAdrszMessFloat @ float
bl affichageMess
b 5f
3:
cmp r0,#3
bne 5f
ldr r0,iAdrszMessFloatExp @ float with exposant
bl affichageMess
5:
b loop
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc 0 @ perform system call
iAdrszMessNum: .int szMessNum
iAdrszMessError: .int szMessError
iAdrszMessInteger: .int szMessInteger
iAdrszMessFloat: .int szMessFloat
iAdrszMessFloatExp: .int szMessFloatExp
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsBuffer: .int sBuffer
/******************************************************************/
/* control if string is number */
/******************************************************************/
/* r0 contains the address of the string */
/* r0 return 0 if not a number */
/* r0 return 1 if integer eq 12345 or -12345 */
/* r0 return 2 if float eq 123.45 or 123,45 or -123,45 */
/* r0 return 3 if float with exposant eq 123.45E30 or -123,45E-30 */
controlNumber:
push {r1-r4,lr} @ save registers
mov r1,#0
mov r3,#0 @ point counter
1:
ldrb r2,[r0,r1]
cmp r2,#0
beq 5f
cmp r2,#' '
addeq r1,#1
beq 1b
cmp r2,#'-' @ negative ?
addeq r1,#1
beq 2f
cmp r2,#'+' @ positive ?
addeq r1,#1
2:
ldrb r2,[r0,r1] @ control space
cmp r2,#0 @ end ?
beq 5f
cmp r2,#' '
addeq r1,#1
beq 2b
3:
ldrb r2,[r0,r1]
cmp r2,#0 @ end ?
beq 10f
cmp r2,#'E' @ exposant ?
beq 6f
cmp r2,#'e' @ exposant ?
beq 6f
cmp r2,#'.' @ point ?
addeq r3,#1 @ yes increment counter
addeq r1,#1
beq 3b
cmp r2,#',' @ comma ?
addeq r3,#1 @ yes increment counter
addeq r1,#1
beq 3b
cmp r2,#'0' @ control digit < 0
blt 5f
cmp r2,#'9' @ control digit > 0
bgt 5f
add r1,#1 @ no error loop digit
b 3b
5: @ error detected
mov r0,#0
b 100f
6: @ float with exposant
add r1,#1
ldrb r2,[r0,r1]
cmp r2,#0 @ end ?
moveq r0,#0 @ error
beq 100f
cmp r2,#'-' @ negative exposant ?
addeq r1,#1
mov r4,#0 @ nombre de chiffres
7:
ldrb r2,[r0,r1]
cmp r2,#0 @ end ?
beq 9f
cmp r2,#'0' @ control digit < 0
blt 8f
cmp r2,#'9' @ control digit > 0
bgt 8f
add r1,#1
add r4,#1 @ counter digit
b 7b
8:
mov r0,#0
b 100f
9:
cmp r4,#0 @ number digit exposant = 0 -> error
moveq r0,#0 @ erreur
beq 100f
cmp r4,#2 @ number digit exposant > 2 -> error
movgt r0,#0 @ error
bgt 100f
mov r0,#3 @ valid float with exposant
b 100f
10:
cmp r3,#0
moveq r0,#1 @ valid integer
beq 100f
cmp r3,#1 @ number of point or comma = 1 ?
moveq r0,#2 @ valid float
movgt r0,#0 @ error
100:
pop {r1-r4,lr} @ restaur des 2 registres
bx lr @ return
/******************************************************************/
/* display text with size calculation */
/******************************************************************/
/* r0 contains the address of the message */
affichageMess:
push {r0,r1,r2,r7,lr} @ save registers
mov r2,#0 @ counter length */
1: @ loop length calculation
ldrb r1,[r0,r2] @ read octet start position + index
cmp r1,#0 @ if 0 its over
addne r2,r2,#1 @ else add 1 in the length
bne 1b @ and loop
@ so here r2 contains the length of the message
mov r1,r0 @ address message in r1
mov r0,#STDOUT @ code to write to the standard output Linux
mov r7, #WRITE @ code call system "write"
svc #0 @ call system
pop {r0,r1,r2,r7,lr} @ restaur registers
bx lr @ return
Arturo
print numeric? "hello world"
print numeric? "1234"
print numeric? "1234 hello world"
print numeric? "12.34"
print numeric? "!#@$"
print numeric? "-1.23"
- Output:
false true false true false true
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
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")}'
- Output:
0 1
BaCon
INPUT "Your string: ", s$
IF REGEX(s$, "^[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?$") THEN
PRINT "This is a number"
ELSE
PRINT "Not a number"
ENDIF
- Output:
user@host $ ./isnumber Your string: 12.3 This is a number user@host $ ./isnumber Your string: 12E3 This is a number user@host $ ./isnumber Your string: PI Not a number user@host $ ./isnumber Your string: Hello Not a number
BASIC
10 INPUT "Enter a string";S$:GOSUB 1000
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$
1099 RETURN
BASIC256
#La función isNumeric() es nativa de BASIC256.
#Devuelve 1 (verdadero) si la expresión es un entero,
#un número de punto flotante o una cadena que se puede
#convertir directamente en un número.
#De lo contrario, devuelve 0 (falso).
#Las siguientes cadenas numéricas son válidas:
#“123”, “-345”, “234.234324”, “-34234.123”, “-2.567e7” y “6.7888E-8”.
s = "1234.056789"
print s, " => "; isNumeric(s)
s = "-2.567e7"
print s, " => "; isNumeric(s)
s = "Dog"
print s, " => "; isNumeric(s)
s = "Bad125"
print s, " => "; isNumeric(s)
s = "-0177"
print s, " => "; isNumeric(s)
s = "0b1110" #binario
print s, " => "; isNumeric(s)
s = "0o177" #octal
print s, " => "; isNumeric(s)
s = "0xff" #hexadecimal
print s, " => "; isNumeric(s)
end
- Output:
1234.056789 => 1 -2.567e7 => 1 Dog => 0 Bad125 => 0 -0177 => 1 0b1110 => 1 0o177 => 1 0xff => 0
Commodore BASIC
5 print chr$(147);chr$(14)
10 input "Enter a string";s$:gosub 1000:print
20 if r then print "You entered a number.":goto 99
30 print "That is not a number."
99 end
1000 t1=val(s$):t1$=str$(t1)
1010 r=t1$=s$ or t1$=" "+s$
1099 return
- Output:
Enter a string? 15893 You entered a number. ready. run Enter a string? Llamas That is not a number. ready. █
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.
If v$ = Str$(Val(v$)) Then 'Str$() converts numeric values to their string counter parts and Val() does the opposite,
'converting strings to their numerical values. By converting the value of whatever is stored
'in v$ to a number and then back to a string it will have either stayed completely the same,
'in which case it is a numeric value (including exponent and hex and oct based numbers) or
'what is returned by the nested Str$() and Val$() functions will be different, in which case
'one, the other, or both returned an error or a truncation of the original string which began
'with numeric characters but was not entirely a number, such as "99, rue de Rivoli".
Print "Your entered a number."
Else
Print "You did not enter a number."
End If
Sleep
System
- Output:
Enter a text or a number: 12345 You entered a number. Enter a text or a number: Four You did not enter a number. Enter a text or a number: 99, rue de Rivoli You did not enter a number. Enter a text or a number: 9E4 You entered a number.
NB: While "99, rue de Rivoli" contains a number it is not a number entirely. The Val(v$) in this case would have stopped after it converted the "99" portion of the input, which when converted back to a string and compared to the original input would not result in an equality. 9E4 the program reads as an exponential value.
SmallBASIC
y = isnumber(s) returns true if s is a number or can be converted to a number.
a = 1.2345
b = "abc"
c = "-1.2345"
print isnumber(a)
print isnumber(b)
print isnumber(c)
- Output:
1 0 1
Batch File
set /a a=%arg%+0 >nul
if %a% == 0 (
if not "%arg%"=="0" (
echo Non Numeric.
) else (
echo Numeric.
)
) else (
echo Numeric.
)
BBC BASIC
REPEAT
READ N$
IF FN_isanumber(N$) THEN
PRINT "'" N$ "' is a number"
ELSE
PRINT "'" N$ "' is NOT a number"
ENDIF
UNTIL N$ = "end"
END
DATA "PI", "0123", "-0123", "12.30", "-12.30", "123!", "0"
DATA "0.0", ".123", "-.123", "12E3", "12E-3", "12+3", "end"
DEF FN_isanumber(A$)
ON ERROR LOCAL = FALSE
IF EVAL("(" + A$ + ")") <> VAL(A$) THEN = FALSE
IF VAL(A$) <> 0 THEN = TRUE
IF LEFT$(A$,1) = "0" THEN = TRUE
= FALSE
- Output:
'PI' is NOT a number '0123' is a number '-0123' is a number '12.30' is a number '-12.30' is a number '123!' is NOT a number '0' is a number '0.0' is a number '.123' is a number '-.123' is a number '12E3' is a number '12E-3' is a number '12+3' is NOT a number 'end' is NOT a number
Befunge
~:0\`#v_:"+"-!#v_:"-"-!#v_::"E"-\"e"-*#v_ v
v _v# < < 0<
>~:0\`#v_>::"0"-0\`\"9"-0`+!#v_:"."-!#v_::"E"-\"e"-*!#v_ v
^ $< > > $ v
>~:0\`#v_>::"0"-0\`\"9"-0`+!#v_:"."-!#v_::"E"-\"e"-*!#v_> v>
^ $< >$~:0\`#v_:"+"-#v_v
v $_v# < < :#<
>~:0\`#v_>::"0"-0\`\"9"-0`+!#v_:"."-!#v_::"E"-\"e"-*!v 0 > v
^ $< v < << ^_^#-"-"<
> "ciremuN">:#,_@ >>#$_"ciremun toN">:#,_@^ <
Although only integer inputs are strictly allowed in Befunge, the code tries to adhere to the floating point conventions in other languages when recognising valid numbers.
- Output:
'PI' Not numeric '0123' Numeric '-0123' Numeric '12.30' Numeric '-12.30' Numeric '123!' Not numeric '0' Numeric '0.0' Numeric '.123' Numeric '-.123' Numeric '12E3' Numeric '12E-3' Numeric '12+3' Not numeric 'end' Not numeric '12..34' Not numeric '12e3.4' Not numeric '192.168.0.1' Not numeric
BQN
IsNumeric ← 1∘•ParseFloat⎊0
Bracmat
To check whether a string is a number, a fraction or an integer, use the patterns #
, /
and ~/#
("not a fraction and yet a number"). In the pattern matching examples below (which can be typed in at the Bracmat prompt) F
denotes 'failure' and S
denotes 'success'.
43257349578692:/
F
260780243875083/35587980:/
S
247/30:~/#
F
80000000000:~/#
S
The pattern ~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#)
recognises string representations of floating point numbers.
@("1.000-4E-10":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))
F
@("1.0004E-54328":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))
S
@("-464641.0004E-54328":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))
S
@("1/2.0004E-10":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))
F
@("1357E-10":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))
S
@("1357e0":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))
S
@("13579":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))
S
@("1.246":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))
S
@("0.0":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))
S
@("0.0000":~/# (|"." (|? 0|`) (|~/#:>0)) (|(E|e) ~/#))
S
Calculations with floating point numbers are delegated to UFP (Un-I-fancy-fied Floating Point, because it took me 30 years to dream up a viable way to do FP in Bracmat without breaking existing code) objects. An UFP object compiles and executes code that only handles C "doubles" and (multidimensional) arrays of such values.
Burlesque
ps^^-]to{"Int""Double"}\/~[\/L[1==?*
Assumes string is not empty.
C
Returns true (non-zero) if character-string parameter represents a signed or unsigned floating-point number. Otherwise returns false (zero).
#include <ctype.h>
#include <stdbool.h>
#include <stdlib.h>
bool isNumeric(const char *s) {
if (s == NULL || *s == '\0' || isspace(*s)) {
return false;
}
char *p;
strtod(s, &p);
return *p == '\0';
}
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;
}
}
C++
#include <cctype>
#include <cstdlib>
bool isNumeric(const char *s) {
if (s == nullptr || *s == '\0' || std::isspace(*s)) {
return false;
}
char *p;
std::strtod(s, &p);
return *p == '\0';
}
Using stringstream:
#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 );
}
Using find:
bool isNumeric( const char* pszInput, int nNumberBase )
{
string base = "0123456789ABCDEF";
string input = pszInput;
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);
}
CFScript
ColdFusion Script (CfScript)
isNumeric(42)
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
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])
(defn number-string? [s]
(boolean
(when (and (string? s) (re-matches #"^[+-]?\d.*" s))
(let [reader (PushbackReader. (StringReader. s))
num (try (edn/read reader) (catch Exception _ nil))]
(when num
; Check that the string has nothing after the number
(= -1 (.read reader)))))))
user=> (number-string? "2r101010")
true
user=> (number-string? "22/7")
true
COBOL
Intrinsic Functions
COBOL has the intrinsic functions TEST-NUMVAL
and TEST-NUMVAL-C
to check if a string is numeric (TEST-NUMVAL-C
is used to check if it is also a monetary string). Implementations supporting the 20XX draft standard can also use TEST-NUMVAL-F
for floating-point numbers. They return 0 if the string is valid, or the position of the first incorrect character.
program-id. is-numeric.
procedure division.
display function test-numval-f("abc") end-display
display function test-numval-f("-123.01E+3") end-display
if function test-numval-f("+123.123") equal zero then
display "is numeric" end-display
else
display "failed numval-f test" end-display
end-if
goback.
Implementation
IDENTIFICATION DIVISION.
PROGRAM-ID. Is-Numeric.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 Numeric-Chars PIC X(10) VALUE "0123456789".
01 Success CONSTANT 0.
01 Failure CONSTANT 128.
LOCAL-STORAGE SECTION.
01 I PIC 99.
01 Num-Decimal-Points PIC 99.
01 Num-Valid-Chars PIC 99.
LINKAGE SECTION.
01 Str PIC X(30).
PROCEDURE DIVISION USING Str.
IF Str = SPACES
MOVE Failure TO Return-Code
GOBACK
END-IF
MOVE FUNCTION TRIM(Str) TO Str
INSPECT Str TALLYING Num-Decimal-Points FOR ALL "."
IF Num-Decimal-Points > 1
MOVE Failure TO Return-Code
GOBACK
ELSE
ADD Num-Decimal-Points TO Num-Valid-Chars
END-IF
IF Str (1:1) = "-" OR "+"
ADD 1 TO Num-Valid-Chars
END-IF
PERFORM VARYING I FROM 1 BY 1 UNTIL I > 10
INSPECT Str TALLYING Num-Valid-Chars
FOR ALL Numeric-Chars (I:1) BEFORE SPACE
END-PERFORM
INSPECT Str TALLYING Num-Valid-Chars FOR TRAILING SPACES
IF Num-Valid-Chars = FUNCTION LENGTH(Str)
MOVE Success TO Return-Code
ELSE
MOVE Failure TO Return-Code
END-IF
GOBACK
.
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
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>
Alternative solution
<cfoutput>#isNumeric(42)#</cfoutput>
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.
(defun numeric-string-p (string)
(let ((*read-eval* nil))
(ignore-errors (numberp (read-from-string string)))))
ignore-errors
here handles returning nil in case the input is invalid rather than simply non-numeric.
However, read
[-from-string
] 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 #*
, which takes a length). The parse-number
library provides a numbers-only equivalent of read
.
(defun numeric-string-p (string)
(ignore-errors (parse-number:parse-number string))) ; parse failed, return false (nil)
D
Standard Version
Using the standard Phobos function (currently binary and hex literals are not recognized):
import std.stdio, std.string, std.array;
void main() {
foreach (const s; ["12", " 12\t", "hello12", "-12", "02",
"0-12", "+12", "1.5", "1,000", "1_000",
"0x10", "0b10101111_11110000_11110000_00110011",
"-0b10101", "0x10.5"])
writefln(`isNumeric("%s"): %s`, s, s.strip().isNumeric(true));
}
- Output:
isNumeric("12"): true isNumeric(" 12 "): true isNumeric("hello12"): false isNumeric("-12"): true isNumeric("02"): true isNumeric("0-12"): false isNumeric("+12"): true isNumeric("1.5"): true isNumeric("1,000"): true isNumeric("1_000"): true isNumeric("0x10"): false isNumeric("0b10101111_11110000_11110000_00110011"): false isNumeric("-0b10101"): false isNumeric("0x10.5"): false
An Implementation
import std.stdio, std.string, std.conv, std.array, std.exception;
bool isNumeric(in string s) pure {
immutable s2 = s.strip.toLower.replace("_", "").replace(",", "");
try {
s2.to!real;
} catch (ConvException e) {
if (s2.startsWith("0x"))
return !s2[2 .. $].to!ulong(16)
.collectException!ConvException;
else if (s2.startsWith("0b"))
return !s2[2 .. $].to!ulong(2)
.collectException!ConvException;
else
return false;
}
return true;
}
void main() {
foreach (immutable s; ["12", " 12\t", "hello12", "-12", "02",
"0-12", "+12", "1.5", "1,000", "1_000",
"0x10", "0b10101111_11110000_11110000_00110011",
"-0b10101", "0x10.5"])
writefln(`isNumeric("%s"): %s`, s, s.isNumeric);
}
- Output:
isNumeric("12"): true isNumeric(" 12 "): true isNumeric("hello12"): false isNumeric("-12"): true isNumeric("02"): true isNumeric("0-12"): false isNumeric("+12"): true isNumeric("1.5"): true isNumeric("1,000"): true isNumeric("1_000"): true isNumeric("0x10"): true isNumeric("0b10101111_11110000_11110000_00110011"): true isNumeric("-0b10101"): false isNumeric("0x10.5"): false
Delphi
This simple function is a wrapper around a built-in Delphi function
function IsNumericString(const inStr: string): Boolean;
var
i: extended;
begin
Result := TryStrToFloat(inStr,i);
end;
This console application tests the function:
program isNumeric;
{$APPTYPE CONSOLE}
uses
Classes,
SysUtils;
function IsNumericString(const inStr: string): Boolean;
var
i: extended;
begin
Result := TryStrToFloat(inStr,i);
end;
{ Test function }
var
s: string;
c: Integer;
const
MAX_TRIES = 10;
sPROMPT = 'Enter a string (or type "quit" to exit):';
sIS = ' is numeric';
sISNOT = ' is NOT numeric';
begin
c := 0;
s := '';
repeat
Inc(c);
Writeln(sPROMPT);
Readln(s);
if (s <> '') then
begin
tmp.Add(s);
if IsNumericString(s) then
begin
Writeln(s+sIS);
end
else
begin
Writeln(s+sISNOT);
end;
Writeln('');
end;
until
(c >= MAX_TRIES) or (LowerCase(s) = 'quit');
end.
- Output:
Example summarised
123 is numeric -123.456 is numeric -123.-456 is NOT numeric .345 is numeric m1k3 is NOT numeric
Dyalect
func String.IsNumeric() {
try {
parse(this) is Integer or Float
} catch _ {
false
}
}
var str = "1234567"
print(str.IsNumeric())
Déjà Vu
is-numeric s:
true
try:
drop to-num s
catch value-error:
not
for v in [ "1" "0" "3.14" "hello" "12e3" "12ef" "-3" ]:
!.( v is-numeric v )
- Output:
"-3" true "12ef" false "12e3" true "hello" false "3.14" true "0" true "1" true
E
def isNumeric(specimen :String) {
try {
<import:java.lang.makeDouble>.valueOf(specimen)
return true
} catch _ {
return false
}
}
EasyLang
func is_numeric a$ .
h = number a$
# because every variable must be used
h = h
return 1 - error
.
for s$ in [ "abc" "21a" "1234" "-13" "7.65" ]
if is_numeric s$ = 1
print s$ & " is numeric"
else
print s$ & " is not numeric"
.
.
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
(string->number -666)
→ -666
(if (string->number 666) 'YES 'NO)
→ YES
Ed
H
g/^([-+]?[0-9]*)(\.[0-9]+([eE][+-]?[0-9]+)?)?$/s//\1\2 is numeric/
v/numeric/s/.*/& is not numeric/
,p
Q
- Output:
$ cat string-numeric.ed | ed -GlEs string-numeric.input Newline appended 56233 is numeric -315 is numeric 1.36 is numeric -5.126 is numeric 3.7E-05 is numeric 1.23BC is not numeric 5.6.3 is not numeric
Elixir
defmodule RC do
def is_numeric(str) do
case Float.parse(str) do
{_num, ""} -> true
_ -> false
end
end
end
["123", "-12.3", "123.", ".05", "-12e5", "+123", " 123", "abc", "123a", "12.3e", "1 2"] |> Enum.filter(&RC.is_numeric/1)
- Output:
["123", "-12.3", "-12e5", "+123"]
Emacs Lisp
(defun string-valid-number-p (str)
"Test if STR is a numeric string.
Eliminate strings with commas in them because ELisp numbers do
not contain commas. Then check if remaining strings would be
valid ELisp numbers if the quotation marks were removed."
(and
;; no comma in string, because ELisp numbers do not have commas
;; we need to eliminate any string with a comma, because the
;; numberp function below will not weed out commas
(not (string-match-p "," str))
;; no errors from numberp function testing if a number
(ignore-errors (numberp (read str)))))
- Output:
Below is ELisp code to test two lists. One is a list of strings that would be acceptable numbers in Emacs ELisp. The second is a list of strings that are not valid numbers. The code tests each string in each list.
(setq valid-strings '("3" "0" "-0" "2." "1000" "-4" "-5." "6.2" "-8.45" "+15e2" "-15e2" "#b101100" "#o54" "#x2c" "1500.0" "#24r1k" "3"))
(setq invalid-strings '("3cat" "1,000" "5.6.7" "cat3" "def" "zero"))
(with-current-buffer (pop-to-buffer "my-test")
(erase-buffer)
(insert "Test for valid strings:\n")
(dolist (test-string valid-strings)
(let ((test-result))
(setq test-result (string-valid-number-p test-string))
(insert (format "%-8s - %s \n" test-string test-result))))
(insert "\n" "\n")
(insert "Test for invalid strings:\n")
(dolist (test-string invalid-strings)
(let ((test-result))
(setq test-result (string-valid-number-p test-string))
(insert (format "%-5s - %s \n" test-string test-result)))))
Below is the result of the tests:
Test for valid strings: 3 - t 0 - t -0 - t 2. - t 1000 - t -4 - t -5. - t 6.2 - t -8.45 - t +15e2 - t -15e2 - t #b101100 - t #o54 - t #x2c - t 1500.0 - t #24r1k - t 3 - t Test for invalid strings: 3cat - nil 1,000 - nil 5.6.7 - nil cat3 - nil def - nil zero - nil
EMal
fun isNumeric = logic by text value
try
^|So funny:
|a) we check if it's castable to a real
|b) we obtain the real 0.0
|c) conversion from real to int to get 0
|d) int can be converted to logical to get ⊥
|e) we can negate the result
|^
return not when(value.contains("."), logic!int!(real!value * 0), logic!(int!value * 0))
remedy
return false
end
end
fun main = int by List args
if args.length == 1
writeLine(isNumeric(args[0]))
else
writeLine("value".padEnd(8, " ") + " " + "numeric")
for each text value in text["0o755", "thursday", "3.14", "0b1010", "-100", "0xff"]
writeLine(value.padEnd(8, " ") + " " + isNumeric(value))
end
end
return 0
end
exit main(Runtime.args)
- Output:
value numeric 0o755 ⊤ thursday ⊥ 3.14 ⊤ 0b1010 ⊤ -100 ⊤ 0xff ⊤
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).
ERRE
Short form using predeclared ERRE functions VAL and STR$.
PROGRAM NUMERIC
PROCEDURE IS_NUMERIC(S$->ANS%)
LOCAL T1,T1$
T1=VAL(S$)
T1$=STR$(T1)
ANS%=(T1$=S$) OR T1$=" "+S$
END PROCEDURE
BEGIN
PRINT(CHR$(12);)
INPUT("Enter a string",S$)
IS_NUMERIC(S$->ANS%)
IF ANS% THEN PRINT("is num") ELSE PRINT("not num")
END PROGRAM
- Output:
Enter a string? 12.30 is num
Euphoria
include get.e
function is_numeric(sequence s)
sequence val
val = value(s)
return val[1]=GET_SUCCESS and atom(val[2])
end function
F#
let is_numeric a = fst (System.Double.TryParse a)
Factor
: numeric? ( string -- ? ) string>number >boolean ;
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
{
// function to see if str contains a number of any of built-in types
static Bool readNum (Str str)
{
int := Int.fromStr (str, 10, false) // use base 10
if (int != null) return true
float := Float.fromStr (str, false)
if (float != null) return true
decimal := Decimal.fromStr (str, false)
if (decimal != null) return true
return false
}
public static Void main ()
{
echo ("For '2': " + readNum ("2"))
echo ("For '-2': " + readNum ("-2"))
echo ("For '2.5': " + readNum ("2.5"))
echo ("For '2a5': " + readNum ("2a5"))
echo ("For '-2.1e5': " + readNum ("-2.1e5"))
}
}
- Output:
For '2': true For '-2': true For '2.5': true For '2a5': false For '-2.1e5': true
Another example inspired by the Kotlin example. Fantom does not have an enhanced for-loop (foreach) loop, but instead uses Closures as the primary mechanism of iteration.
/* gary chike 08/27/2023 */
class Main {
static Void main() {
inputs := ["152\n", "-3.141", "Foo123", "-0", "456bar", "1.0E10"]
inputs.each |Str input| { echo("$input.trim \tis " + (isNumeric(input) ? "numeric" : "not numeric"))}
static Bool isNumeric(Str input) {
try {
input.toFloat
return true
}
catch(Err e) {
return false
}
}
}
- Output:
152 is numeric -3.141 is numeric Foo123 is not numeric -0 is numeric 456bar is not numeric 1.0E10 is numeric
Forth
: 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 )
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
Free Pascal
function isNumeric(const potentialNumeric: string): boolean;
var
potentialInteger: integer;
potentialReal: real;
integerError: integer;
realError: integer;
begin
integerError := 0;
realError := 0;
// system.val attempts to convert numerical value representations.
// It accepts all notations as they are accepted by the language,
// as well as the '0x' (or '0X') prefix for hexadecimal values.
val(potentialNumeric, potentialInteger, integerError);
val(potentialNumeric, potentialReal, realError);
isNumeric := (integerError = 0) or (realError = 0);
end;
The following is a more complete and compilable example.
program IsNumeric;
type
TDynamicArrayItem = record
StrValue: string;
end;
var
myDynamicArray: array of TDynamicArrayItem;
i: Integer;
Value: Extended;
Code: Integer;
begin
// Initialize the dynamic array with different data types
SetLength(myDynamicArray, 7);
myDynamicArray[0].StrValue := 'Hello';
myDynamicArray[1].StrValue := '42';
myDynamicArray[2].StrValue := '3.14159';
myDynamicArray[3].StrValue := 'World';
myDynamicArray[4].StrValue := '99';
myDynamicArray[5].StrValue := '0777'; // Octal representation for 511
myDynamicArray[6].StrValue := '$A1'; // Hexadecimal representation for 161
// Iterate through the dynamic array and determine data type
for i := Low(myDynamicArray) to High(myDynamicArray) do
begin
Val(myDynamicArray[i].StrValue, Value, Code);
if Code = 0 then // The value 0 for Code indicates that the conversion was successful.
Writeln('Element ', i, ': Numeric Value ', Chr(9),' - ', Value) // Chr(9) = tab
else
Writeln('Element ', i, ': Non-Numeric Value ', Chr(9), ' - ', myDynamicArray[i].StrValue);
end;
end.
{ Val converts the value represented in the string 'StrValue' to a numerical value or an enumerated value, and stores this value in the variable 'Value', which can be of type Longint, Real and Byte or any enumerated type. If the conversion isn't successful, then the parameter 'Code' contains the index of the character in 'StrValue' which prevented the conversion. }
- Output:
Free Pascal Compiler version 3.2.2 [2021/10/28] for x86_64 Copyright (c) 1993-2021 by Florian Klaempfl and others Target OS: Darwin for x86_64 Compiling arrVariantIsNumeric.pas Assembling arrvariantisnumeric Linking arrVariantIsNumeric 37 lines compiled, 0.3 sec Element 0: Non-Numeric Value - Hello Element 1: Numeric Value - 4.20000000000000000000E+0001 Element 2: Numeric Value - 3.14158999999999999993E+0000 Element 3: Non-Numeric Value - World Element 4: Numeric Value - 9.90000000000000000000E+0001 Element 5: Numeric Value - 7.77000000000000000000E+0002 Element 6: Non-Numeric Value - $A1
FreeBASIC
FreeBASIC has a built-in Val() function which converts numeric strings to doubles. However, it is not ideal for the present task since it will try to convert as much of the string as it can (so "123xyz" would convert to 123) and return 0 if a conversion on this basis is not possible (i.e. "xyz" would return 0).
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.
' FB 1.05.0 Win64
Dim Shared symbols(0 To 15) As UByte
For i As Integer = 48 to 57
symbols(i - 48) = i
Next
For i As Integer = 97 to 102
symbols(i - 87) = i
Next
Const plus As UByte = 43
Const minus As Ubyte = 45
Const dot As UByte = 46
Function isNumeric(s As Const String, base_ As Integer = 10) As Boolean
If s = "" OrElse s = "." OrElse s = "+" OrElse s = "-" Then Return False
Err = 0
If base_ < 2 OrElse base_ > 16 Then
Err = 1000
Return False
End If
Dim t As String = LCase(s)
If (t[0] = plus) OrElse (t[0] = minus) Then
t = Mid(t, 2)
End If
If Left(t, 2) = "&h" Then
If base_ <> 16 Then Return False
t = Mid(t, 3)
End if
If Left(t, 2) = "&o" Then
If base_ <> 8 Then Return False
t = Mid(t, 3)
End if
If Left(t, 2) = "&b" Then
If base_ <> 2 Then Return False
t = Mid(t, 3)
End if
If Len(t) = 0 Then Return False
Dim As Boolean isValid, hasDot = false
For i As Integer = 0 To Len(t) - 1
isValid = False
For j As Integer = 0 To base_ - 1
If t[i] = symbols(j) Then
isValid = True
Exit For
End If
If t[i] = dot Then
If CInt(Not hasDot) AndAlso (base_ = 10) Then
hasDot = True
IsValid = True
Exit For
End If
Return False ' either more than one dot or not base 10
End If
Next j
If Not isValid Then Return False
Next i
Return True
End Function
Dim s As String
s = "1234.056789"
Print s, " (base 10) => "; isNumeric(s)
s = "1234.56"
Print s, " (base 7) => "; isNumeric(s, 7)
s = "021101"
Print s, " (base 2) => "; isNumeric(s, 2)
s = "Dog"
Print s, " (base 16) => "; isNumeric(s, 16)
s = "Bad125"
Print s, " (base 16) => "; isNumeric(s, 16)
s = "-0177"
Print s, " (base 8) => "; isNumeric(s, 8)
s = "+123abcd.ef"
Print s, " (base 16) => "; isNumeric(s, 8)
s = "54321"
Print s, " (base 6) => "; isNumeric(s, 6)
s = "123xyz"
Print s, " (base 10) => "; isNumeric(s)
s = "xyz"
Print s, " (base 10) => "; isNumeric(s)
Print
Print "Press any key to quit"
Sleep
- Output:
1234.056789 (base 10) => true 1234.56 (base 7) => false 021101 (base 2) => false Dog (base 16) => false Bad125 (base 16) => true -0177 (base 8) => true +123abcd.ef (base 16) => false 54321 (base 6) => true 123xyz (base 10) => false xyz (base 10) => false
FutureBasic
include "NSLog.incl"
local fn StringIsNumeric( string as CFStringRef ) as BOOL
BOOL flag = NO
ScannerRef scanner = fn ScannerWithString( string )
if ( fn ScannerScanFloat( scanner, NULL ) )
flag = fn ScannerIsAtEnd( scanner )
end if
end fn = flag
NSLog(@"%d",fn StringIsNumeric( @"1.23" ))
NSLog(@"%d",fn StringIsNumeric( @"-123.4e5" ))
NSLog(@"%d",fn StringIsNumeric( @"alpha" ))
HandleEvents
- Output:
1 1 0
Gambas
Public Sub Form_Open()
Dim sAnswer, sString As String
sString = Trim(InputBox("Enter as string", "String or Numeric"))
If IsNumber(sString) Then sAnswer = "'" & sString & "' is numeric" Else sAnswer = "'" & sString & "' is a string"
Print sAnswer
End
Output:
'Charlie' is a string '-00.256666' is numeric
Go
This uses a library function to meet the task's requirements:
package main
import (
"fmt"
"strconv"
)
func isNumeric(s string) bool {
_, err := strconv.ParseFloat(s, 64)
return err == nil
}
func main() {
fmt.Println("Are these strings numeric?")
strings := []string{"1", "3.14", "-100", "1e2", "NaN", "rose"}
for _, s := range strings {
fmt.Printf(" %4s -> %t\n", s, isNumeric(s))
}
}
- Output:
Are these strings numeric? 1 -> true 3.14 -> true -100 -> true 1e2 -> true NaN -> true rose -> false
This uses both a library function and a custom one but only checks for integerness:
package main
import (
"fmt"
"strconv"
"unicode"
)
func isInt(s string) bool {
for _, c := range s {
if !unicode.IsDigit(c) {
return false
}
}
return true
}
func main() {
fmt.Println("Are these strings integers?")
v := "1"
b := false
if _, err := strconv.Atoi(v); err == nil {
b = true
}
fmt.Printf(" %3s -> %t\n", v, b)
i := "one"
fmt.Printf(" %3s -> %t\n", i, isInt(i))
}
- Output:
Are these strings integers? 1 -> true one -> false
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
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.
Haxe
Haxe has a built-in function that will convert a string to an integer, so we can use that to determine if the string is numeric or not.
static function isNumeric(n:String):Bool
{
if (Std.parseInt(n) != null) //Std.parseInt converts a string to an int
{
return true; //as long as it results in an integer, the function will return true
}
else
{
return false;
}
}
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
i
concept numeric(n) {
number(n)
errors {
print(n, " is not numeric!")
return
}
print(n, " is numeric :)")
}
software {
numeric("1200")
numeric("3.14")
numeric("3/4")
numeric("abcdefg")
numeric("1234test")
}
Icon and 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.
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
Insitux
Non-null and non-false values are truthy in Insitux. The operation to-num returns null if it is unable to parse its string parameter, else the parsed number. The operation bool is unnecessary in most situations, but is composed with to-num here to satisfy the task specification.
> (var numeric? (comp to-num bool))
(comp to-num bool)
> (numeric? "123")
true
> (numeric? "0x25")
true
> (numeric? "0b0101")
true
> (numeric? "hello")
false
> (numeric? "123x456")
false
J
isNumeric=: _ ~: _ ". ]
isNumericScalar=: 1 -: isNumeric
TXT=: ,&' a scalar numeric value.' &.> ' is not';' represents'
sayIsNumericScalar=: , TXT {::~ isNumericScalar
Examples of use:
isNumeric '152'
1
isNumeric '152 -3.1415926 Foo123'
1 1 0
isNumeric '42 foo42 4.2e1 4200e-2 126r3 16b2a 42foo'
1 0 1 1 1 1 0
isNumericScalar '152 -3.1415926 Foo123'
0
sayIsNumericScalar '-3.1415926'
-3.1415926 represents a scalar numeric value.
Java
Typically, you would use the 'parse' methods from either the Integer, Long, Float, or Double class,
which will throw a NumberFormatException for ill-formed values.
For example
Integer.parseInt("12345")
Float.parseFloat("123.456")
The performance mark is somewhat negligible between a try-block and custom methods.
public static void main(String[] args) {
String value;
value = "1234567";
System.out.printf("%-10s %b%n", value, isInteger(value));
value = "12345abc";
System.out.printf("%-10s %b%n", value, isInteger(value));
value = "-123.456";
System.out.printf("%-10s %b%n", value, isFloatingPoint(value));
value = "-.456";
System.out.printf("%-10s %b%n", value, isFloatingPoint(value));
value = "123.";
System.out.printf("%-10s %b%n", value, isFloatingPoint(value));
value = "123.abc";
System.out.printf("%-10s %b%n", value, isFloatingPoint(value));
}
static boolean isInteger(String string) {
String digits = "0123456789";
for (char character : string.toCharArray()) {
if (!digits.contains(String.valueOf(character)))
return false;
}
return true;
}
static boolean isFloatingPoint(String string) {
/* at least one decimal-point */
int indexOf = string.indexOf('.');
if (indexOf == -1)
return false;
/* assure only 1 decimal-point */
if (indexOf != string.lastIndexOf('.'))
return false;
if (string.charAt(0) == '-' || string.charAt(0) == '+') {
string = string.substring(1);
indexOf--;
}
String integer = string.substring(0, indexOf);
if (!integer.isEmpty()) {
if (!isInteger(integer))
return false;
}
String decimal = string.substring(indexOf + 1);
if (!decimal.isEmpty())
return isInteger(decimal);
return true;
}
1234567 true 12345abc false -123.456 true -.456 true 123. true 123.abc false
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();
}
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).
JavaScript
A far better validator can be found on StackOverflow[1]
function isNumeric(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
var value = "123.45e7"; // Assign string literal to value
if (isNumeric(value)) {
// value is a number
}
//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')}
jq
Works with jq, the C implementation of jq
Works with gojq, the Go implementation of jq
Works with jaq, the Rust implementation of jq
The simplest way to test if a string can be parsed as a number is:
try tonumber catch false
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:
def is_numeric: true and try tonumber catch false;
Julia
The function isnumber tests for strings that parse directly to numbers. This test excludes symbols, such as π and 1 + 1, 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.
using Printf
isnumber(s::AbstractString) = tryparse(Float64, s) isa Number
tests = ["1", "-121", "one", "pi", "1 + 1", "NaN", "1234567890123456789", "1234567890123456789123456789",
"1234567890123456789123456789.0", "1.3", "1.4e10", "Inf", "1//2", "1.0 + 1.0im"]
for t in tests
fl = isnumber(t) ? "is" : "is not"
@printf("%35s %s a direct numeric literal.\n", t, fl)
end
- Output:
1 is a direct numeric literal. -121 is a direct numeric literal. one is not a direct numeric literal. pi is not a direct numeric literal. 1 + 1 is not a direct numeric literal. NaN is a direct numeric literal. 1234567890123456789 is a direct numeric literal. 1234567890123456789123456789 is a direct numeric literal. 1234567890123456789123456789.0 is a direct numeric literal. 1.3 is a direct numeric literal. 1.4e10 is a direct numeric literal. Inf is a direct numeric literal. 1//2 is not a direct numeric literal. 1.0 + 1.0im is not a direct numeric literal.
Kotlin
// version 1.1
fun isNumeric(input: String): Boolean =
try {
input.toDouble()
true
} catch(e: NumberFormatException) {
false
}
fun main(args: Array<String>) {
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"}")
}
- Output:
152 is numeric -3.1415926 is numeric Foo123 is not numeric -0 is numeric 456bar is not numeric 1.0E10 is numeric
LabVIEW
This image is a VI Snippet, an executable image of LabVIEW code. The LabVIEW version is shown on the top-right hand corner. You can download it, then drag-and-drop it onto the LabVIEW block diagram from a file browser, and it will appear as runnable, editable code.
Lasso
local(str='12345')
string_isNumeric(#str) // true
'12345'->isdigit // true
'1X34Q'->isdigit // false
Liberty BASIC
DATA "PI", "0123", "-0123", "12.30", "-12.30", "123!", "0"
DATA "0.0", ".123", "-.123", "12E3", "12E-3", "12+3", "end"
while n$ <> "end"
read n$
print n$, IsNumber(n$)
wend
end
function IsNumber(string$)
on error goto [NotNumber]
string$ = trim$(string$)
'check for float overflow
n = val(string$)
'assume it is number and try to prove wrong
IsNumber = 1
for i = 1 to len(string$)
select case mid$(string$, i, 1)
case "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
HasNumeric = 1 'to check if there are any digits
case "e", "E"
'"e" must not occur more than once
'must not occur before digits
if HasE > 0 or HasNumeric = 0 then
IsNumber = 0
exit for
end if
HasE = i 'store position of "e"
HasNumeric = 0 'needs numbers after "e"
case "-", "+"
'must be either first character or immediately after "e"
'(HasE = 0 if no occurrences yet)
if HasE <> i-1 then
IsNumber = 0
exit for
end if
case "."
'must not have previous points and must not come after "e"
if HasE <> 0 or HasPoint <> 0 then
IsNumber = 0
exit for
end if
HasPoint = 1
case else
'no other characters allowed
IsNumber = 0
exit for
end select
next i
'must have digits
if HasNumeric = 0 then IsNumber = 0
[NotNumber]
end function
Lisaac
"123457".is_integer.println;
// write TRUE on stdin
Logo
show number? "-1.23 ; true
Lua
This will also accept strings like "0xFF" or "314.16e-2" as numbers.
if tonumber(a) ~= nil then
--it's a number
end;
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 {
function global isNumber(a$, de$=".") {
=false=true ' return boolean
if de$="" then de$=str$(.1,".") ' get current decimal point character
a$=trim$(ucase$(a$))
m=len(a$)
if m=0 then exit
c$=filter$(a$,"0123456789")
if c$ = "" then {
=true
} else.if m>1 then {
\ may have -+ and ,
if m=2 then {
if not c$~"[-+\"+de$+"]" then break
} else {
if left$(c$,1 ) ~"[+-]" then c$=mid$(c$, 2)
if not (c$=de$ or c$=de$+"E" or c$ ~ de$+"E[+-]") then break
if c$ ~ de$+"E[+-]" then if not (instr(a$,"E+")>0 or instr(a$,"E-")>0) then break
}
if de$<>"." then a$=replace$(de$, ".", a$, 1,1)
try {inline "a="+a$+"=="+a$}
if valid(a) then =a = true=true ' return boolean
}
}
Print isNumber("+1"), isnumber("-1"), isNumber("1+")=false, isnumber("1-")=false
Print isNumber(",1",","), isnumber("1,",","), isNumber(",0",","), isnumber("0,", ",")
Print isNumber(".1"), isnumber("1."), isNumber(".0"), isnumber("0.")
Print isNumber("+.1"), isnumber("-1."), isNumber(".12e+232"), isnumber("0.122e10")
Print isNumber("+.1a")=false, isnumber("asasa1212")=false, isNumber("1.2e43+23")=false, isnumber("0.122e10")
Print isNumber("1221.211.1221")=false, isnumber("1221e1212")=false, isNumber("1.2e4323")=false, isnumber("-.122e-10")
}
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
=val(false->boolean)
Try {
if islet then {
z=val(a$,letter$, m)
} else.if isnum then {
z=val(a$,number, m)
} else z=val(a$,"", m)
=m>len(a$)
}
}
Function IsIntegerNumeric(a$) {
def m
=val(false->boolean)
Try {
z=val(a$,"Int", m)
=m>len(a$)
}
}
Locale 1033 ' to use . as decimal, else we have to place 1033 or "." as second parameter
Print isNumeric("+1"), isNumeric("-1"), isNumeric("1+")=false, isNumeric("1-")=false
Print isNumeric(",1",","), isNumeric("1,",","), isNumeric(",0",","), isNumeric("0,", ",")
Print isNumeric(".1"), isNumeric("1."), isNumeric(".0"), isNumeric("0.")
Print isNumeric("+.1"), isNumeric("-1."), isNumeric(".12e+232"), isNumeric("0.122e10")
Print isNumeric("+.1a")=false, isNumeric("asasa1212")=false, isNumeric("1.2e43+23")=false, isNumeric("0.122e10")
Print isNumeric("1221.211.1221")=false, isNumeric("1221e1212")=false, isNumeric("1.2e4323")=false, isNumeric("-.122e-10")
Maple
isNumeric := proc(s)
try
if type(parse(s), numeric) then
printf("The string is numeric."):
else
printf("The string is not numeric."):
end if:
catch:
printf("The string is not numeric."):
end try:
end proc:
Mathematica / Wolfram Language
NumberQ[ToExpression["02553352000242"]]
MATLAB
function r = isnum(a)
r = ~isnan(str2double(a))
end
% tests
disp(isnum(123)) % 1
disp(isnum("123")) % 1
disp(isnum("foo123")) % 0
disp(isnum("123bar")) % 0
disp(isnum("3.1415")) % 1
Maxima
numberp(parse_string("170141183460469231731687303715884105727"));
MAXScript
fn isNumeric str =
(
try
(
(str as integer) != undefined
)
catch(false)
)
isNumeric "123"
min
(
dup (((int integer?) (pop false)) try) dip
((float float?) (pop false)) try or
) :numeric?
MiniScript
We rely on conversion to number returning a nonzero number, plus special checks for zero strings. Note that the val
function is forgiving about additional characters after the number, so our function is too.
isNumeric = function(s)
return s == "0" or s == "-0" or val(s) != 0
end function
print isNumeric("0")
print isNumeric("42")
print isNumeric("-3.14157")
print isNumeric("5@*#!")
print isNumeric("spam")
- Output:
1 1 1 1 0
MIPS Assembly
# $a0 char val
# $a1 address pointer
# $a2 PERIOD_HIT_FLAG
# $a3 HAS_DIGITS_FLAG
.data
### CHANGE THIS STRING TO TEST DIFFERENT ONES... ###
string: .asciiz "-.1236"
s_false: .asciiz "False"
s_true: .asciiz "True"
.text
main:
set_up: #test for 0th char == 45 or 46 or 48...57
la $a1,string
lb $a0,($a1)
beq $a0,45,loop # == '-'
beq $a0,46,loop # == '.'
blt $a0,48,exit_false # isn't below the ascii range for chars '0'...'9'
bgt $a0,57,exit_false # isn't above the ascii range for chars '0'...'9'
loop:
addi $a1,$a1,1
lb $a0,($a1)
beqz $a0,exit_true # test for \0 null char
beq $a0,46,period_test #test for a duplicate period
blt $a0,48,exit_false #test for
bgt $a0,57,exit_false
la $a3,1 #set the HAS_DIGITS flag. This line is only reached because the
# tests for period and - both jump back to start.
j loop
exit_true:
beqz $a3,exit_false
la $a0,s_true
la $v0,4
syscall
li $v0,10
syscall
exit_false:
la $a0,s_false
la $v0,4
syscall
li $v0,10
syscall
period_test:
beq $a2,1,exit_false
li $a2,1
j loop
Mirah
import java.text.NumberFormat
import java.text.ParsePosition
import java.util.Scanner
# this first example relies on catching an exception,
# which is bad style and poorly performing in Java
def is_numeric?(s:string)
begin
Double.parseDouble(s)
return true
rescue
return false
end
end
puts '123 is numeric' if is_numeric?('123')
puts '-123 is numeric' if is_numeric?('-123')
puts '123.1 is numeric' if is_numeric?('123.1')
puts 'nil is not numeric' unless is_numeric?(nil)
puts "'' is not numeric" unless is_numeric?('')
puts 'abc is not numeric' unless is_numeric?('abc')
puts '123- is not numeric' unless is_numeric?('123-')
puts '1.2.3 is not numeric' unless is_numeric?('1.2.3')
# check every element of the string
def is_numeric2?(s: string)
if (s == nil || s.isEmpty())
return false
end
if (!s.startsWith('-'))
if s.contains('-')
return false
end
end
0.upto(s.length()-1) do |x|
c = s.charAt(x)
if ((x == 0) && (c == '-'.charAt(0)))
# negative number
elsif (c == '.'.charAt(0))
if (s.indexOf('.', x) > -1)
return false # more than one period
end
elsif (!Character.isDigit(c))
return false
end
end
true
end
puts '123 is numeric' if is_numeric2?('123')
puts '-123 is numeric' if is_numeric2?('-123')
puts '123.1 is numeric' if is_numeric2?('123.1')
puts 'nil is not numeric' unless is_numeric2?(nil)
puts "'' is not numeric" unless is_numeric2?('')
puts 'abc is not numeric' unless is_numeric2?('abc')
puts '123- is not numeric' unless is_numeric2?('123-')
puts '1.2.3 is not numeric' unless is_numeric2?('1.2.3')
# use a regular expression
def is_numeric3?(s:string)
s == nil || s.matches("[-+]?\\d+(\\.\\d+)?")
end
puts '123 is numeric' if is_numeric3?('123')
puts '-123 is numeric' if is_numeric3?('-123')
puts '123.1 is numeric' if is_numeric3?('123.1')
puts 'nil is not numeric' unless is_numeric3?(nil)
puts "'' is not numeric" unless is_numeric3?('')
puts 'abc is not numeric' unless is_numeric3?('abc')
puts '123- is not numeric' unless is_numeric3?('123-')
puts '1.2.3 is not numeric' unless is_numeric3?('1.2.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.
def is_numeric4?(s:string)
return false if s == nil
formatter = NumberFormat.getInstance()
pos = ParsePosition.new(0)
formatter.parse(s, pos)
s.length() == pos.getIndex()
end
puts '123 is numeric' if is_numeric4?('123')
puts '-123 is numeric' if is_numeric4?('-123')
puts '123.1 is numeric' if is_numeric4?('123.1')
puts 'nil is not numeric' unless is_numeric4?(nil)
puts "'' is not numeric" unless is_numeric4?('')
puts 'abc is not numeric' unless is_numeric4?('abc')
puts '123- is not numeric' unless is_numeric4?('123-')
puts '1.2.3 is not numeric' unless is_numeric4?('1.2.3')
# use the java.util.Scanner object. Very useful if you have to
# scan multiple entries. 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).
def is_numeric5?(s:string)
return false if s == nil
Scanner sc = Scanner.new(s)
sc.hasNextDouble()
end
puts '123 is numeric' if is_numeric5?('123')
puts '-123 is numeric' if is_numeric5?('-123')
puts '123.1 is numeric' if is_numeric5?('123.1')
puts 'nil is not numeric' unless is_numeric5?(nil)
puts "'' is not numeric" unless is_numeric5?('')
puts 'abc is not numeric' unless is_numeric5?('abc')
puts '123- is not numeric' unless is_numeric5?('123-')
puts '1.2.3 is not numeric' unless is_numeric5?('1.2.3')
mIRC Scripting Language
var %value = 3
if (%value isnum) {
echo -s %value is numeric.
}
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
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
Nanoquery
def isNum(str)
try
double(str)
return true
catch
return false
end
end
Nemerle
using System;
using System.Console;
module IsNumeric
{
IsNumeric( input : string) : bool
{
mutable meh = 0.0; // I don't want it, not going to use it, why force me to declare it?
double.TryParse(input, out meh)
}
Main() : void
{
def num = "-1.2345E6";
def not = "abc45";
WriteLine($"$num is numeric: $(IsNumeric(num))");
WriteLine($"$not is numeric: $(IsNumeric(not))");
}
}
NetRexx
/* NetRexx */
options replace format comments java crossref symbols nobinary
numeric digits 20
loop n_ over getTestData()
-- could have used n_.datatype('N') directly here...
if isNumeric(n_) then msg = 'numeric'
else msg = 'not numeric'
say ('"'n_'"').right(25)':' msg
end n_
return
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- Pointless in NetRexx; the DATATYPE built-in-function is more powerful!
method isNumeric(testString) public static returns boolean
return testString.datatype('N')
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method getTestData() private static returns Rexx[]
-- Coercing numbers into the Rexx type has the effect of converting them to strings.
-- NetRexx will still perform arithmetic on Rexx strings if those strings represent numbers.
-- Notice that whitespace between the sign and the number are ignored even when inside a string constant
testData = [ Rexx -
' one and a half', 1, 1.5, 1.5e+27, ' 1 ', ' 1.5 ', ' 1.5e+27 ', -
'-one and a half', - 1, - 1.5, - 1.5e-27, ' - 1 ', '- 1.5 ', '- 1.5e-27 ', -
'+one and a half', + 1, + 1.5, + 1.5e+27, ' + 1 ', '+ 1.5 ', '+ 1.5e+27 ', -
'Math Constants', -
Math.PI, Math.E, -
-Math.PI, -Math.E, -
+Math.PI, +Math.E, -
'Numeric Constants', -
Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY -
]
return testData
- Output:
" one and a half": not numeric "1": numeric "1.5": numeric "1.5e+27": numeric " 1 ": numeric " 1.5 ": numeric " 1.5e+27 ": numeric "-one and a half": not numeric "-1": numeric "-1.5": numeric "-1.5E-27": numeric " - 1 ": numeric "- 1.5 ": numeric "- 1.5e-27 ": numeric "+one and a half": not numeric "1": numeric "1.5": numeric "1.5E+27": numeric " + 1 ": numeric "+ 1.5 ": numeric "+ 1.5e+27 ": numeric "Math Constants": not numeric "3.141592653589793": numeric "2.718281828459045": numeric "-3.141592653589793": numeric "-2.718281828459045": numeric "3.141592653589793": numeric "2.718281828459045": numeric "Numeric Constants": not numeric "NaN": not numeric "Infinity": not numeric "Infinity": not numeric
Nim
import strutils
proc isNumeric(s: string): bool =
try:
discard s.parseFloat()
result = true
except ValueError:
result = false
const Strings = ["1", "3.14", "-100", "1e2", "Inf", "rose"]
for s in Strings:
echo s, " is ", if s.isNumeric(): "" else: "not ", "numeric"
We could prefer to use the “parsutils” module which avoids the exception:
import parseutils
proc isNumeric(s: string): bool =
var x: float
s.parseFloat(x) == s.len
const Strings = ["1", "3.14", "-100", "1e2", "Inf", "rose"]
for s in Strings:
echo s, " is ", if s.isNumeric(): "" else: "not ", "numeric"
- Output:
1 is numeric 3.14 is numeric -100 is numeric 1e2 is numeric Inf is numeric rose is not numeric
Nu
def is-numeric [] {try {into float | true} catch {false}}
["1" "12" "-3" "5.6" "-3.14" "one" "cheese"] | each {{k: $in, v: ($in | is-numeric)}}
- Output:
╭───┬────────┬───────╮ │ # │ k │ v │ ├───┼────────┼───────┤ │ 0 │ 1 │ true │ │ 1 │ 12 │ true │ │ 2 │ -3 │ true │ │ 3 │ 5.6 │ true │ │ 4 │ -3.14 │ true │ │ 5 │ one │ false │ │ 6 │ cheese │ false │ ╰───┴────────┴───────╯
Objeck
class Numeric {
function : Main(args : String[]) ~ Nil {
if(args->Size() = 1) {
IsNumeric(args[0])->PrintLine();
};
}
function : IsNumeric(str : String) ~ Bool {
return str->IsFloat();
}
}
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.
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.
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
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
r = ~isnan(str2double(a));
endif
endfunction
% tests
disp(isnum(123)) % 1
disp(isnum("123")) % 1
disp(isnum("foo123")) % 0
disp(isnum("123bar")) % 0
disp(isnum("3.1415")) % 1
Odin
package main
import "core:strconv"
import "core:fmt"
is_numeric :: proc(s: string) -> bool {
_, ok := strconv.parse_f32(s)
return ok
}
main :: proc() {
strings := []string{"1", "3.14", "-100", "1e2", "Inf", "rose"}
for s in strings {
fmt.println(s, "is", is_numeric(s) ? "numeric" : "not numeric")
}
}
/* Output:
1 is numeric
3.14 is numeric
-100 is numeric
1e2 is numeric
Inf is not numeric
rose is not numeric
*/
Oz
fun {IsNumeric S}
{String.isInt S} orelse {String.isFloat S}
end
PARI/GP
isNumeric(s)={
my(t=type(eval(s)));
t == "t_INT" || t == "T_REAL"
};
Pascal
See Delphi or Free Pascal.
PascalABC.NET
function IsNumeric(s: string): boolean;
begin
var i: integer;
Result := integer.TryParse(s,i)
end;
begin
var s := '123';
if IsNumeric(s) then
Print('string is numeric')
end.
PeopleCode
Built-In Function
Syntax
IsNumber(Value)
Description
Use the IsNumber function to determine if Value contains a valid numeric value. Numeric characters include sign indicators and comma and period decimal points.
To determine if a value is a number and if it's in the user's local format, use the IsUserNumber function.
Parameters
Value
Specify a string you want to search to determine if it is a valid number.
Returns
A Boolean value: True if Value contains a valid numeric value, False otherwise.
Example
&Value = Get Field().Value;
If IsNumber(&Value) Then
/* do numeric processing */
Else
/* do non-numeric processing */
End-if;
Perl
use Scalar::Util qw(looks_like_number);
print looks_like_number($str) ? "numeric" : "not numeric\n";
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+\z/) { print "is a whole number\n" }
if (/^-?\d+\z/) { print "is an integer\n" }
if (/^[+-]?\d+\z/) { print "is a +/- integer\n" }
if (/^-?\d+\.?\d*\z/) { print "is a real number\n" }
if (/^-?(?:\d+(?:\.\d*)?&\.\d+)\z/) { print "is a decimal number\n" }
if (/^([+-]?)(?=\d&\.\d)\d*(\.\d*)?([Ee]([+-]?\d+))?\z/)
{ 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.
Phix
function isNumber(string s) return scanf(s,"%f")!={} -- Alt: isNumberString(object s) and -- return string(s) and scanf(s,"%f")!={}, or even -- return string(s) and scanf(substitute(trim(s),",",""),"%f")!={} end function constant tests = {"#a","#A","0xA","0(16)A","#FF","255","0", "0.","0.0","000.000","0e0","0e-2000"," ", ".14",".05","-5.2","0xf","ten","1B","#1B", " 12 ",trim(" 12 "),"1","0o16","0o18", "0b10101111_11110000_11110000_00110011", "1_000","50e","+123","+ 123","-0b10101", "NaN","+.345","12..34","12e3.4","0-2", "192.168.0.1","1.2e","1 2","12.34","", "beef","#beef","1,000,000","Inf","1/2", "1.5e+27","0x10.5","1."} sequence numeric = {}, notnumb = {} for i=1 to length(tests) do string ti = tests[i] if isNumber(ti) then numeric = append(numeric,ti) else notnumb = append(notnumb,ti) end if end for puts(1,"numeric: ") pp(numeric,{pp_Indent,9}) puts(1,"\nnot numeric: ") pp(notnumb,{pp_Indent,13})
- Output:
numeric: {`#a`, `#A`, `0xA`, `0(16)A`, `#FF`, `255`, `0`, `0.0`, `000.000`, `0e0`, `0e-2000`, `.14`, `.05`, `-5.2`, `0xf`, `#1B`, `12`, `1`, `0o16`, `0b10101111_11110000_11110000_00110011`, `1_000`, `+123`, `-0b10101`, `+.345`, `12.34`, `#beef`, `1.5e+27`, `0x10.5`} not numeric: {`0.`, ` `, `ten`, `1B`, ` 12 `, `0o18`, `50e`, `+ 123`, `NaN`, `12..34`, `12e3.4`, `0-2`, `192.168.0.1`, `1.2e`, `1 2`, ``, `beef`, `1,000,000`, `Inf`, `1/2`, `1.`}
Should you want to check for (eg) complex numbers, your best bet is to (also) invoke scanf() with several other different format strings such as "%f+%fi", "%f-%fj" (etc), until one works, or they all fail.
PHP
<?php
$string = '123';
if(is_numeric(trim($string))) {
}
?>
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
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)
{
array test = array_sscanf(s, "%s%f%s");
if (sizeof(test) == 3 && test[1] && !sizeof(test[0]) && !sizeof(test[2]) )
return true;
else
return false;
}
string num = "-1.234"
is_number(num);
-> true
PL/I
is_numeric: procedure (text) returns (bit (1));
declare text character (*);
declare x float;
on conversion go to done;
get string(text) edit (x) (E(length(text),0));
return ('1'b);
done:
return ('0'b);
end is_numeric;
5 '1'B 6.7 '1'B -8.9 '1'B -4e3 '1'B 4A37 '0'B
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;
Plain English
The following decider exists in the noodle
To decide if a string is any numeric literal:
and is used to resolve the If clause
If the string is any numeric literal,
in this solution.
To run:
Start up.
Show whether "cat" is numeric.
Show whether "3" is numeric.
Show whether "+3" is numeric.
Show whether "-123" is numeric.
Show whether "123,456" is numeric.
Show whether "11/5" is numeric.
Show whether "-26-1/3" is numeric.
Show whether "+26-1/3" is numeric.
Show whether "1/0" is numeric. \in Plain English, 1/0 is 0. Don't tell the mathematicians!
Show whether "3.14159" is numeric. \floating point is not implemented in Plain English.
Wait for the escape key.
Shut down.
To show whether a string is numeric:
Write the string then " -> " on the console without advancing.
If the string is any numeric literal, write "yes" on the console; exit.
Write "no" on the console.
- Output:
cat -> no 3 -> yes +3 -> yes -123 -> yes 123,456 -> no 11/5 -> yes -26-1/3 -> yes +26-1/3 -> yes 1/0 -> yes 3.14159 -> no
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
}
}
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.
function isNumeric ($x) {
$x2 = 0
$isNum = [System.Int32]::TryParse($x, [ref]$x2)
return $isNum
}
Prolog
The code:
numeric_string(String) :-
atom_string(Atom, String),
atom_number(Atom, _).
A predicate to test the code:
test_strings(Strings) :-
forall( member(String, Strings),
( ( numeric_string(String)
-> Result = a
; Result = 'not a' ),
format('~w is ~w number.~n', [String, Result])
)
).
Example of using the test predicate:
?- test_strings(["123", "0.123", "-123.1", "NotNum", "1."]).
123 is a number.
0.123 is a number.
-123.1 is a number.
NotNum is not a number.
1. is not a number.
true.
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
- Output:
'+3183.31151E+321' = 1 '-123456789' = 1 '123.45.6789+' = 0 '-e' = 0
Python
Python: Simple int/float
def is_numeric(s):
try:
float(s)
return True
except (ValueError, TypeError):
return False
is_numeric('123.0')
Or for positive integers only:
'123'.isdigit()
Python: Most numeric literals
Including complex, hex, binary, and octal numeric literals we get:
def is_numeric(literal):
"""Return whether a literal can be parsed as a numeric value"""
castings = [int, float, complex,
lambda s: int(s,2), #binary
lambda s: int(s,8), #octal
lambda s: int(s,16)] #hex
for cast in castings:
try:
cast(literal)
return True
except ValueError:
pass
return False
Sample use, including value parsed, its type, and standard method str.isnumeric():
def numeric(literal):
"""Return value of numeric literal or None if can't parse a value"""
castings = [int, float, complex,
lambda s: int(s,2), #binary
lambda s: int(s,8), #octal
lambda s: int(s,16)] #hex
for cast in castings:
try:
return cast(literal)
except ValueError:
pass
return None
tests = [
'0', '0.', '00', '123', '0123', '+123', '-123', '-123.', '-123e-4', '-.8E-04',
'0.123', '(5)', '-123+4.5j', '0b0101', ' +0B101 ', '0o123', '-0xABC', '0x1a1',
'12.5%', '1/2', '½', '3¼', 'π', 'Ⅻ', '1,000,000', '1 000', '- 001.20e+02',
'NaN', 'inf', '-Infinity']
for s in tests:
print("%14s -> %-14s %-20s is_numeric: %-5s str.isnumeric: %s" % (
'"'+s+'"', numeric(s), type(numeric(s)), is_numeric(s), s.isnumeric() ))
- Output:
"0" -> 0 <class 'int'> is_numeric: True str.isnumeric: True "0." -> 0.0 <class 'float'> is_numeric: True str.isnumeric: False "00" -> 0 <class 'int'> is_numeric: True str.isnumeric: True "123" -> 123 <class 'int'> is_numeric: True str.isnumeric: True "0123" -> 123 <class 'int'> is_numeric: True str.isnumeric: True "+123" -> 123 <class 'int'> is_numeric: True str.isnumeric: False "-123" -> -123 <class 'int'> is_numeric: True str.isnumeric: False "-123." -> -123.0 <class 'float'> is_numeric: True str.isnumeric: False "-123e-4" -> -0.0123 <class 'float'> is_numeric: True str.isnumeric: False "-.8E-04" -> -8e-05 <class 'float'> is_numeric: True str.isnumeric: False "0.123" -> 0.123 <class 'float'> is_numeric: True str.isnumeric: False "(5)" -> (5+0j) <class 'complex'> is_numeric: True str.isnumeric: False "-123+4.5j" -> (-123+4.5j) <class 'complex'> is_numeric: True str.isnumeric: False "0b0101" -> 5 <class 'int'> is_numeric: True str.isnumeric: False " +0B101 " -> 5 <class 'int'> is_numeric: True str.isnumeric: False "0o123" -> 83 <class 'int'> is_numeric: True str.isnumeric: False "-0xABC" -> -2748 <class 'int'> is_numeric: True str.isnumeric: False "0x1a1" -> 417 <class 'int'> is_numeric: True str.isnumeric: False "12.5%" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False "1/2" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False "½" -> None <class 'NoneType'> is_numeric: False str.isnumeric: True "3¼" -> None <class 'NoneType'> is_numeric: False str.isnumeric: True "π" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False "Ⅻ" -> None <class 'NoneType'> is_numeric: False str.isnumeric: True "1,000,000" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False "1 000" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False "- 001.20e+02" -> None <class 'NoneType'> is_numeric: False str.isnumeric: False "NaN" -> nan <class 'float'> is_numeric: True str.isnumeric: False "inf" -> inf <class 'float'> is_numeric: True str.isnumeric: False "-Infinity" -> -inf <class 'float'> is_numeric: True str.isnumeric: False
Python: Regular expressions
import re
numeric = re.compile('[-+]?(\d+(\.\d*)?|\.\d+)([eE][-+]?\d+)?')
is_numeric = lambda x: numeric.fullmatch(x) != None
is_numeric('123.0')
Quackery
[ char . over find
tuck over found iff
[ swap pluck drop ]
else nip ] is -point ( $ --> $ )
[ -point $->n nip ] is numeric ( $ --> b )
[ dup echo$ say " is"
numeric not if say " not"
say " a valid number." cr ] is task ( $ --> )
$ "152" task
$ "-3.1415926" task
$ "Foo123" task
- Output:
152 is a valid number. -3.1415926 is a valid number. Foo123 is not a valid number.
R
> strings <- c("152", "-3.1415926", "Foo123")
> suppressWarnings(!is.na(as.numeric(strings)))
[1] TRUE TRUE FALSE
Racket
(define (string-numeric? s) (number? (string->number s)))
Or, since all non-#f are true:
(define string-numeric? string->number)
Raku
(formerly Perl 6)
Raku tries very hard to DWIM (do what I mean). As part of that, numeric strings are by default stored as allomorphic types which can be used as numbers or strings without any conversion. If we truly want to operate on strings, we have to explicitly coerce the allomorphs to strings. A subtlety that may not be immediately apparent, whitespace, empty strings and null strings may be treated as (False) boolean values in Raku, however booleans are allomorphic to numeric, so empty strings will coerce to a numeric value (0), and return as numeric unless specifically checked for. Interestingly, the actual strings 'True' and 'False' don't evaluate as numeric. (because there are no String | Boolean allomorphs.)
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.
sub is-number-w-ws( Str $term --> Bool ) { # treat Falsey strings as numeric
$term.Numeric !~~ Failure;
}
sub is-number-wo-ws( Str $term --> Bool ) { # treat Falsey strings as non-numeric
?($term ~~ / \S /) && $term.Numeric !~~ Failure;
}
say " Coerce Don't coerce";
say ' String whitespace whitespace';
printf "%10s %8s %11s\n",
"<$_>", .&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
0o18 2+5i True False Inf NaN 0x10.50 0b102 0o_5_3 ௫௯>, ' 12 ', '1 1 1', '', ' ' ).map: *.Str;
Coerce Don't coerce String whitespace whitespace <1> True True <1.2> True True <1.2.3> False False <-6> True True <1/2> True True <12e> False False <B17> False False <1.3e+12> True True <1.3e12> True True <-2.6e-3> True True <zero> False False <0x> False False <0xA10> True True <0b1001> True True <0o16> True True <0o18> False False <2+5i> True True <True> False False <False> False False <Inf> True True <NaN> True True <0x10.50> True True <0b102> False False <0o_5_3> True True <௫௯> True True < 12 > True True <1 1 1> False False <> True False < > True False
RapidQ
isnumeric
$Typecheck on
Defint FALSE, TRUE
FALSE = 0
TRUE = NOT FALSE
Function isNumeric(s as string, optchar as string) as integer
If len(s) = 0 then
Result = FALSE
Exit Function
End If
if instr(s,"+") > 1 then
Result = FALSE
exit function
end if
if instr(s,"-") > 1 then
Result = FALSE
exit function
end if
Defint i, ndex = 0
For i = 1 to len(s)
select case asc(mid$(s,i,1))
case 43 '+
case 45 '-
case 46 '.
if ndex = 1 then
Result = FALSE
Exit function
end if
ndex = 1
case 48 to 57 '0 to 9
case else
if instr(optchar,(mid$(s,i,1))) = 0 then
Result = FALSE
exit function
end if
end select
next
Result = TRUE
End Function
'============================================================
'Begin
'============================================================
showmessage (str$(isNumeric("-152.34","")))
end
REBOL
REBOL [
Title: "Is Numeric?"
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]]
Retro
Retro does not have floating point numbers as part of the core system. For others, this can be done with:
'123 a:from-string TRUE [ swap c:digit? and ] a:reduce
REXX
/*REXX program determines if a string is numeric, using REXX's rules for numbers. */
yyy=' -123.78' /*or some such. */
/*strings below are all numeric (REXX).*/
zzz= ' -123.78 '
zzz= '-123.78'
zzz= '2'
zzz= "2"
zzz= 2
zzz= '000000000004'
zzz= '+5'
zzz= +5
zzz= ' +6 '
zzz= ' + 7 '
zzz= ' - 8 '
zzz= ' - .9'
zzz= '- 19.'
zzz= '.7'
zzz= .7
zzz= '2e3'
zzz= 47e567
zzz= '2e-3'
zzz= '1.2e1'
zzz= ' .2E6'
zzz= ' 2.e5 '
zzz= ' +1.2E0002 '
zzz= ' +1.2e+002 '
zzz= ' +0000001.200e+002 '
zzz= ' - 000001.200e+002 '
zzz= ' - 000008.201e-00000000000000002 '
/*Note: some REXX interpreters allow use of tab chars as blanks. */
/*all statements below are equivalent.*/
if \datatype(yyy, 'n') then say 'oops, not numeric:' yyy
if \datatype(yyy, 'N') then say 'oops, not numeric:' yyy
if ¬datatype(yyy, 'N') then say 'oops, not numeric:' yyy
if ¬datatype(yyy, 'numeric') then say 'oops, not numeric:' yyy
if ¬datatype(yyy, 'nimrod.') then say 'oops, not numeric:' yyy
if datatype(yyy) \== 'NUM' then say 'oops, not numeric:' yyy
if datatype(yyy) /== 'NUM' then say 'oops, not numeric:' yyy
if datatype(yyy) ¬== 'NUM' then say 'oops, not numeric:' yyy
if datatype(yyy) ¬= 'NUM' then say 'oops, not numeric:' yyy
/*note: REXX only looks at the first char for DATATYPE's 2nd argument.*/
/*note: some REXX interpreters don't support the ¬ (not) character. */
Ring
see isdigit("0123456789") + nl + # print 1
isdigit("0123a") # print 0
RPL
This one-liner returns 1 if the string is either a real number, a complex number or a binary integer - and zero otherwise.
≪ IFERR STR→ THEN DROP 0 ELSE TYPE { 0 1 10 } SWAP POS SIGN END ≫ ‘NUM?’ STO
Ruby
def is_numeric?(s)
begin
Float(s)
rescue
false # not numeric
else
true # numeric
end
end
or more compact:
def is_numeric?(s)
!!Float(s) rescue false
end
NB! Since Ruby 2.6 you no longer need `rescue`:
def is_numeric?(s)
!!Float(s, exception: false)
end
Adding `exception: false` will make it return `nil` instead.
sample
strings = %w(0 0.0 -123 abc 0x10 0xABC 123a -123e3 0.1E-5 50e)
strings.each do |str|
puts "%9p => %s" % [str, is_numeric?(str)]
end
- Output:
"0" => true "0.0" => true "-123" => true "abc" => false "0x10" => true "0xABC" => true "123a" => false "-123e3" => true "0.1E-5" => true "50e" => false
Run BASIC
print isNumeric("123")
print isNumeric("1ab")
' ------------------------
' Numeric Check
' 0 = bad
' 1 = good
' ------------------------
FUNCTION isNumeric(f$)
isNumeric = 1
f$ = trim$(f$)
if left$(f$,1) = "-" or left$(f$,1) = "+" then f$ = mid$(f$,2)
for i = 1 to len(f$)
d$ = mid$(f$,i,1)
if d$ = "," then goto [nxtDigit]
if d$ = "." then
if dot$ = "." then isNumeric = 0
dot$ = "."
goto [nxtDigit]
end if
if (d$ < "0") or (d$ > "9") then isNumeric = 0
[nxtDigit]
next i
END FUNCTION
123 1 1ab 0
Rust
// This function is not limited to just numeric types but rather anything that implements the FromStr trait.
fn parsable<T: FromStr>(s: &str) -> bool {
s.parse::<T>().is_ok()
}
Sample code:
use std::str::FromStr;
fn parsable<T: FromStr>(s: &str) -> bool {
s.parse::<T>().is_ok()
}
fn main() {
let test_cases = [
"142857",
"3.14",
"not of this earth!"
];
let types: &[(&str, fn(&str) -> bool)] = &[
("i32", parsable::<i32> as fn(&str) -> bool),
("i64", parsable::<i32> as fn(&str) -> bool),
("i128", parsable::<i32> as fn(&str) -> bool),
("f64", parsable::<f64> as fn(&str) -> bool),
];
println!("");
for &case in &test_cases {
for &(type_name, parse_fn) in types {
println!(
"'{}' {} be parsed as {}",
case,
if parse_fn(case) { "can" } else { "_cannot_" },
type_name
);
}
println!("");
}
}
- Output:
'142857' can be parsed as i32 '142857' can be parsed as i64 '142857' can be parsed as i128 '142857' can be parsed as f64 '3.14' _cannot_ be parsed as i32 '3.14' _cannot_ be parsed as i64 '3.14' _cannot_ be parsed as i128 '3.14' can be parsed as f64 'not of this earth!' _cannot_ be parsed as i32 'not of this earth!' _cannot_ be parsed as i64 'not of this earth!' _cannot_ be parsed as i128 'not of this earth!' _cannot_ be parsed as f64
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)
}
def throwsNumberFormatException(f: => Any): Boolean = {
try { f; false } catch { case e: NumberFormatException => true }
}
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))
Seed7
The function isNumeric uses the function getNumber from the library scanstri.s7i. GetNumber reads a numeric literal from a string. The numeric literal is removed from the input string.
$ include "seed7_05.s7i";
include "scanstri.s7i";
const func boolean: isNumeric (in var string: stri) is func
result
var boolean: isNumeric is FALSE;
local
var string: numberStri is "";
begin
numberStri := getNumber(stri);
isNumeric := stri = "";
end func;
Sidef
There is the the String.looks_like_number method, which returns true when a given strings looks like a number:
say "0.1E-5".looks_like_number; #=> true
Alternatively, we can use regular expressions to determine this:
func is_numeric(s) {
(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:
var strings = %w(0 0.0 -123 abc 0x10 0xABC 123a -123e3 0.1E-5 50e);
for str in strings {
say ("%9s => %s" % (str, is_numeric(str)))
}
- Output:
0 => true 0.0 => true -123 => true abc => false 0x10 => true 0xABC => true 123a => false -123e3 => true 0.1E-5 => true 50e => false
Simula
Simula uses the '&' instead of 'e' or 'E' for the exponent part of a floating point decimal number.
BEGIN
BOOLEAN PROCEDURE ISNUMERIC(W); TEXT W;
BEGIN
BOOLEAN PROCEDURE MORE;
MORE := W.MORE;
CHARACTER PROCEDURE NEXT;
NEXT := IF MORE THEN W.GETCHAR ELSE CHAR(0);
CHARACTER PROCEDURE LAST;
LAST := IF W.LENGTH = 0
THEN CHAR(0)
ELSE W.SUB(W.LENGTH,1).GETCHAR;
CHARACTER CH;
W.SETPOS(1);
IF MORE THEN
BEGIN
CH := NEXT;
IF CH = '-' OR CH = '+' THEN CH := NEXT;
WHILE DIGIT(CH) DO CH := NEXT;
IF CH = '.' THEN
BEGIN
CH := NEXT;
IF NOT DIGIT(CH) THEN GOTO L;
WHILE DIGIT(CH) DO CH := NEXT;
END;
IF CH = '&' THEN
BEGIN
CH := NEXT;
IF CH = '-' OR CH = '+' THEN CH := NEXT;
WHILE DIGIT(CH) DO CH := NEXT;
END;
END;
L: ISNUMERIC := (W.LENGTH > 0) AND THEN (NOT MORE) AND THEN DIGIT(LAST);
END;
REAL X;
TEXT T;
FOR X := 0, -3.1415, 2.768&+31, 5&10, .5, 5.&10 DO
BEGIN
OUTREAL(X, 10, 20);
OUTIMAGE;
END;
OUTIMAGE;
FOR T :- "0", "-3.1415", "2.768&+31", ".5", "5&22" DO
BEGIN
OUTTEXT(IF ISNUMERIC(T) THEN " NUMERIC " ELSE "NOT NUMERIC ");
OUTCHAR('"');
OUTTEXT(T);
OUTCHAR('"');
IF T = "0" THEN OUTCHAR(CHAR(9)); OUTCHAR(CHAR(9));
COMMENT PROBE ;
X := T.GETREAL;
OUTREAL(X, 10, 20);
OUTIMAGE;
END;
OUTIMAGE;
X := 5.&10;
!X := 5&;
!X := 5.;
X := .5;
FOR T :- "", "5.", "5&", "5&+", "5.&", "5.&-", "5.&10" DO
BEGIN
OUTTEXT(IF ISNUMERIC(T) THEN " NUMERIC " ELSE "NOT NUMERIC ");
OUTCHAR('"');
OUTTEXT(T);
OUTCHAR('"');
OUTIMAGE;
END;
END
- Output:
0.000000000&+000 -3.141500000&+000 2.768000000&+031 5.000000000&+010 5.000000000&-001 5.100000000&+000 NUMERIC "0" 0.000000000&+000 NUMERIC "-3.1415" -3.141500000&+000 NUMERIC "2.768&+31" 2.768000000&+031 NUMERIC ".5" 5.000000000&-001 NUMERIC "5&22" 5.000000000&+022 NOT NUMERIC "" NOT NUMERIC "5." NOT NUMERIC "5&" NOT NUMERIC "5&+" NOT NUMERIC "5.&" NOT NUMERIC "5.&-" NOT NUMERIC "5.&10"
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 ]
(should work with all)
(Number readFrom:(aString readStream) onError:[nil]) notNil
to handle radix numbers (such as 2r10111), use:
(Scanner scanNumberFrom:(aString readStream)) notNil
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
SQL
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'
SQL PL
version 9.7 or higher.
With SQL PL:
--#SET TERMINATOR @
CREATE OR REPLACE FUNCTION IS_NUMERIC (
IN STRING VARCHAR(10)
) RETURNS SMALLINT
-- ) RETURNS BOOLEAN
BEGIN
DECLARE RET SMALLINT;
-- DECLARE RET BOOLEAN;
DECLARE TMP INTEGER;
DECLARE CONTINUE HANDLER FOR SQLSTATE '22018'
SET RET = 1;
-- SET RET = FALSE;
SET RET = 0;
--SET RET = TRUE;
SET TMP = INTEGER(STRING);
RETURN RET;
END @
VALUES IS_NUMERIC('5')@
VALUES IS_NUMERIC('0')@
VALUES IS_NUMERIC('-1')@
VALUES IS_NUMERIC('A')@
VALUES IS_NUMERIC('-')@
VALUES IS_NUMERIC('z')@
VALUES IS_NUMERIC('')@
VALUES IS_NUMERIC(' ')@
Output:
db2 -td@ db2 => BEGIN ... db2 (cont.) => END @ DB20000I The SQL command completed successfully. VALUES IS_NUMERIC('5') 1 ------ 0 1 record(s) selected. VALUES IS_NUMERIC('0') 1 ------ 0 1 record(s) selected. VALUES IS_NUMERIC('-1') 1 ------ 0 1 record(s) selected. VALUES IS_NUMERIC('A') 1 ------ 1 1 record(s) selected. VALUES IS_NUMERIC('-') 1 ------ 1 1 record(s) selected. VALUES IS_NUMERIC('z') 1 ------ 1 1 record(s) selected. VALUES IS_NUMERIC('') 1 ------ 1 1 record(s) selected. VALUES IS_NUMERIC(' ') 1 ------ 1 1 record(s) selected.
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
Swift
func isNumeric(a: String) -> Bool {
return Double(a) != nil
}
This one only checks whether it is an integer:
func isNumeric(a: String) -> Bool {
return a.toInt() != nil
}
Tcl
proc isNumeric str {string is double -strict $str}
TMG
Unix TMG dialect. NOTE: the program also performs some basic normalization (namely, removing the plus sign and translating "E" to "e"):
prog: ignore(<< >>)
parse(line)\prog
parse(error)\prog;
line: number *;
number: ignore(none)
sign float (exp | ={})
= { < True: > 3 2 1 * };
sign: <+>={} | <->={<->} | ={};
float: int ( <.> decim = { 2 <.> 1 } | = { 1 } )
| <.> int = { <.> 1 };
int: smark any(digit) string(digit) scopy;
decim: smark string(digit) scopy;
exp: any(<<eE>>) sign int = { <e> 2 1 };
error: smark any(nonl) ignore(none) string(nonl) scopy * = { <False: > 1 * };
digit: <<0123456789>>;
none: <<>>;
nonl: !<<
>>;
Sample input:
123 +12345.678 .678 1. +1.0E+99 -7. -123e-123 00000 . 1.2.3 0x123 a1-a5 1 000 000 1,000,000 1.00e1e1
Sample output:
True: 123 True: 12345.678 True: .678 True: 1. True: 1.0e99 True: -7. True: -123e-123 True: 00000 False: . False: 1.2.3 False: 0x123 False: a1-a5 False: 1 000 000 False: 1,000,000 False: 1.00e1e1
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 )
True BASIC
DECLARE FUNCTION isnumeric$
LET true$ = "True"
LET false$ = "False"
LET s$ = "-152.34"
PRINT s$, " => "; isnumeric$(s$)
LET s$ = "1234.056789"
PRINT s$, " => "; isnumeric$(s$)
LET s$ = "1234.56"
PRINT s$, " => "; isnumeric$(s$)
LET s$ = "021101"
PRINT s$, " => "; isnumeric$(s$)
LET s$ = "Dog"
PRINT s$, " => "; isnumeric$(s$)
LET s$ = "Bad125"
PRINT s$, " => "; isnumeric$(s$)
LET s$ = "-0177"
PRINT s$, " => "; isnumeric$(s$)
LET s$ = "+123abcd.ef"
PRINT s$, " => "; isnumeric$(s$)
LET s$ = "54321"
PRINT s$, " => "; isnumeric$(s$)
LET s$ = "123xyz"
PRINT s$, " => "; isnumeric$(s$)
LET s$ = "xyz"
PRINT s$, " => "; isnumeric$(s$)
FUNCTION isnumeric$(s$)
LET optchar$ = ""
IF len(s$) = 0 then
LET isnumeric$ = false$
EXIT FUNCTION
END IF
IF pos(s$,"+") > 1 then
LET isnumeric$ = false$
EXIT FUNCTION
END IF
IF pos(s$,"-") > 1 then
LET isnumeric$ = false$
EXIT FUNCTION
END IF
LET ndex = 0
FOR i = 1 to len(s$)
SELECT CASE ord((s$)[i:i+1-1][1:1])
CASE 43 !+
CASE 45 !-
CASE 46 !.
IF ndex = 1 then
LET isnumeric$ = false$
EXIT FUNCTION
END IF
LET ndex = 1
CASE 48 to 57 !0 a 9
CASE else
IF pos(optchar$,((s$)[i:i+1-1])) = 0 then
LET isnumeric$ = false$
EXIT FUNCTION
END IF
END SELECT
NEXT i
LET isnumeric$ = true$
END FUNCTION
END
UNIX Shell
#!/bin/bash
isnum() {
printf "%f" $1 >/dev/null 2>&1
}
check() {
if isnum $1
then
echo "$1 is numeric"
else
echo "$1 is NOT numeric"
fi
}
check 2
check -3
check +45.44
check -33.332
check 33.aa
check 3.3.3
- Output:
2 is numeric -3 is numeric +45.44 is numeric -33.332 is numeric 33.aa is NOT numeric 3.3.3 is NOT numeric
Ursa
def isnum (string str)
try
double str
return true
catch valueerror
return false
end try
end isnum
VBA
In France, IsNumeric("123.45") return False. So we have to check the "." or "," and replace it by the Application.DecimalSeparator.
Sub Main()
Debug.Print Is_Numeric("")
Debug.Print Is_Numeric("-5.32")
Debug.Print Is_Numeric("-51,321 32")
Debug.Print Is_Numeric("123.4")
Debug.Print Is_Numeric("123,4")
Debug.Print Is_Numeric("123;4")
Debug.Print Is_Numeric("123.4x")
End Sub
Private Function Is_Numeric(s As String) As Boolean
Dim Separat As String, Other As String
Separat = Application.DecimalSeparator
Other = IIf(Separat = ",", ".", ",")
Is_Numeric = IsNumeric(Replace(s, Other, Separat))
End Function
VBScript
IsNumeric(Expr)
Returns a True if numeric and a false if not.
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)
}
Visual Basic .NET
Dim Value As String = "+123"
If IsNumeric(Value) Then
PRINT "It is numeric."
End If
V (Vlang)
import strconv
fn is_numeric(s string) bool {
strconv.atof64(s) or {
return false
}
return true
}
fn main() {
println("Are these strings numeric?")
strings := ["1", "3.14", "-100", "1e2", "NaN", "rose", "0xff", "0b110"]
for s in strings {
println(" ${s:4} -> ${is_numeric(s)}")
}
}
- Output:
Are these strings numeric? 1 -> true 3.14 -> true -100 -> true 1e2 -> true NaN -> false rose -> false 0xff -> true 0b110 -> true
Wren
Wren's Num class already has a static method which does what this task requires.
import "./fmt" for Fmt
System.print("Are these strings numeric?")
for (s in ["1", "3.14", "-100", "1e2", "NaN", "0xaf", "rose"]) {
var i = Num.fromString(s) // returns null if 's' is not numeric
System.print(" %(Fmt.s(4, s)) -> %((i != null) ? "yes" : "no")")
}
- Output:
Are these strings numeric? 1 -> yes 3.14 -> yes -100 -> yes 1e2 -> yes NaN -> yes 0xaf -> yes rose -> no
XLISP
The inbuilt function STRING->NUMBER returns the numeric value of a string if it can. We discard this value and return the Boolean value 'true'; otherwise, the IF conditional will not be satisfied and will return 'false'.
(DEFUN NUMERICP (X)
(IF (STRING->NUMBER X) T))
XPL0
The compiler is more strict in the characters it accepts as numeric than what is accepted here. This program indicates more of what the input intrinsics (IntIn, RlIn and HexIn) would accept as numeric.
string 0;
func IsNumeric(Str);
char Str;
[while Str(0) # 0 do
[if Str(0) >= ^0 and Str(0) <= ^9 then return true;
if Str(0) = ^$ then
[if Str(1) >= ^0 and Str(1) <= ^9 then return true;
if Str(1) >= ^A and Str(1) <= ^F then return true;
if Str(1) >= ^a and Str(1) <= ^f then return true;
];
Str:= Str+1;
];
return false;
];
int Strs, S;
[Text(0, "Are these strings numeric?^m^j");
Strs:= ["1", "3.14", "-100", "1e2", "NaN", "$af", "%1_1011", "rose", ". 3", "num9", "x$ 9", "x$ a"];
for S:= 0 to 12-1 do
[Text(0, if IsNumeric(Strs(S)) then "yes : " else "no : ");
Text(0, Strs(S));
CrLf(0);
];
]
- Output:
Are these strings numeric? yes : 1 yes : 3.14 yes : -100 yes : 1e2 no : NaN yes : $af yes : %1_1011 no : rose yes : . 3 yes : num9 yes : x$ 9 no : x$ a
Z80 Assembly
Use the /S8 switch on the ZSM4 assembler for 8 significant characters for labels and names
;
; Check if input string is a number using Z80 assembly language
;
; Runs under CP/M 3.1 on YAZE-AG-2.51.2 Z80 emulator
; Assembled with zsm4 on same emulator/OS, uses macro capabilities of said assembler
; Created with vim under Windows
;
; 2023-04-04 Xorph
;
;
; Useful definitions
;
bdos equ 05h ; Call to CP/M BDOS function
strdel equ 6eh ; Set string delimiter
readstr equ 0ah ; Read string from console
wrtstr equ 09h ; Write string to console
nul equ 00h ; ASCII control characters
esc equ 1bh
cr equ 0dh
lf equ 0ah
cnull equ '0' ; ASCII character constants
cnine equ '9'
cminus equ '-'
cdot equ '.'
buflen equ 30h ; Length of input buffer
minbit equ 00h ; Bit 0 is used as flag for '-'
dotbit equ 01h ; Bit 1 is used as flag for '.'
;
; Macros for BDOS calls
;
setdel macro char ; Set string delimiter to char
ld c,strdel
ld e,char
call bdos
endm
print macro msg ; Output string to console
ld c,wrtstr
ld de,msg
call bdos
endm
newline macro ; Print newline
ld c,wrtstr
ld de,crlf
call bdos
endm
readln macro buf ; Read a line from input
ld c,readstr
ld de,buf
call bdos
endm
;
; =====================
; Start of main program
; =====================
;
cseg
isnum:
setdel nul ; Set string terminator to nul ('\0') - '$' is default in CP/M
print help
newline
newline
readnum:
ld b,buflen ; Clear input buffer
ld hl,bufcont
clrloop:
ld (hl),0
inc hl
djnz clrloop
readln inputbuf ; Read a line from input
newline ; Newline is discarded during input, so write one...
ld a,(inputbuf+1) ; Length of actual input
cp 0 ; If empty input, quit
ret z
ld b,a ; Loop counter for djnz instruction
ld c,0 ; Use c for flags: '-' and '.' may be encountered at most once, '-' only at start
ld hl,bufcont ; Start of actual input
loop:
ld a,(hl) ; Get next character into a
cp cminus ; Check minus sign
jr z,chkminus
cp cdot ; Check dot
jr z,chkdot
cp cnull ; Check if below '0'
jr c,notanum
cp cnine+1 ; Check if above '9'
jr nc,notanum
checknxt:
set minbit,c ; Whatever the case, no more '-' are allowed after the first character
inc hl ; Increase hl to next character and repeat until done
djnz loop
print bufcont ; If we made it this far, we are done and the string is numeric
print yesmsg
newline
newline
done:
jp readnum ; Read next input from user until terminated with ^C or empty input
ret ; Return to CP/M (unreachable code)
notanum:
print bufcont ; Print failure message
print nomsg
newline
newline
jr done
chkminus:
bit minbit,c ; If a '-' is encountered and the flag is already set, the string is not numeric
jr nz,notanum
set minbit,c ; Otherwise, set flag and check next character
jr checknxt
chkdot:
bit dotbit,c ; If a '.' is encountered and the flag is already set, the string is not numeric
jr nz,notanum
set dotbit,c ; Otherwise, set flag and check next character
jr checknxt
;
; ===================
; End of main program
; ===================
;
;
; ================
; Data definitions
; ================
;
dseg
help:
defz 'Enter numbers to check, end with empty line or ^C'
inputbuf: ; Input buffer for CP/M BDOS call
defb buflen ; Maximum possible length
defb 00h ; Returned length of actual input
bufcont:
defs buflen ; Actual input area
defb nul ; Null terminator for output, if buffer is filled completely
yesmsg:
defz ' is numeric'
nomsg:
defz ' is not numeric'
crlf: defb cr,lf,nul ; Generic newline
- Output:
E>isnum Enter numbers to check, end with empty line or ^C 1234 1234 is numeric hello hello is not numeric 12.34 12.34 is numeric -98.76 -98.76 is numeric 4.6.76 4.6.76 is not numeric 34-56-23 34-56-23 is not numeric -.9876543210 -.9876543210 is numeric 444555. 444555. is numeric 1234c 1234c is not numeric 123e45 123e45 is not numeric
Zig
const std = @import("std");
const stdout = std.io.getStdOut().writer();
fn isNumeric(str: []const u8) bool {
const num = std.mem.trim(u8, str, "\x20");
_ = std.fmt.parseFloat(f64, num) catch return false;
return true;
}
pub fn main() !void {
const s1 = " 123";
const s2 = " +123";
const s3 = " 12.3";
const s4 = "-12.3";
const s5 = "12e-3";
const s6 = "=12-3";
const s7 = "abcde";
const s8 = "12cde";
const s9 = "NaN";
const s10 = "0xFF";
try stdout.print("Is {s} numeric? {}\n", .{ s1, isNumeric(s1) });
try stdout.print("Is {s} numeric? {}\n", .{ s2, isNumeric(s2) });
try stdout.print("Is {s} numeric? {}\n", .{ s3, isNumeric(s3) });
try stdout.print("Is {s} numeric? {}\n", .{ s4, isNumeric(s4) });
try stdout.print("Is {s} numeric? {}\n", .{ s5, isNumeric(s5) });
try stdout.print("Is {s} numeric? {}\n", .{ s6, isNumeric(s6) });
try stdout.print("Is {s} numeric? {}\n", .{ s7, isNumeric(s7) });
try stdout.print("Is {s} numeric? {}\n", .{ s8, isNumeric(s8) });
try stdout.print("Is {s} numeric? {}\n", .{ s9, isNumeric(s9) });
try stdout.print("Is {s} numeric? {}\n", .{ s10, isNumeric(s10) });
}
- Output:
Is 123 numeric? true Is +123 numeric? true Is 12.3 numeric? true Is -12.3 numeric? true Is 12e-3 numeric? true Is =12-3 numeric? false Is abcde numeric? false Is 12cde numeric? false Is NaN numeric? true Is 0xFF numeric? true
zkl
fcn isNum(text){
try{ text.toInt(); True }
catch{ try{ text.toFloat(); True }
catch{ False }
}
}
isNum("123.4") //-->True isNum("123") //-->True isNum("-123.4") //-->True isNum("123.4x") //-->False isNum("hoho") //-->False isNum(123.4) //-->True isNum(123) //-->True
Zoea
program: numeric
case: 1 input: '1' output: true
case: 2 input: '-3' output: true
case: 3 input: '22.7' output: true
case: 4 input: 'a' output: false
case: 5 input: 'Fred' output: false
case: 6 input: '' output: false
Zoea Visual
- Programming Tasks
- Text processing
- Simple
- 6502 Assembly
- 8th
- AArch64 Assembly
- Action!
- Action! Tool Kit
- ActionScript
- Ada
- Aime
- ALGOL 68
- ALGOL W
- Apex
- APL
- AppleScript
- ARM Assembly
- Arturo
- AutoHotkey
- AWK
- BaCon
- BASIC
- BASIC256
- Commodore BASIC
- QB64
- SmallBASIC
- Batch File
- BBC BASIC
- Befunge
- BQN
- Bracmat
- Burlesque
- C
- C sharp
- C++
- CFScript
- Clojure
- COBOL
- CoffeeScript
- ColdFusion
- Common Lisp
- D
- Delphi
- Dyalect
- Déjà Vu
- E
- EasyLang
- EchoLisp
- Ed
- Elixir
- Emacs Lisp
- EMal
- Erlang
- ERRE
- Euphoria
- F Sharp
- Factor
- Fantom
- Forth
- Fortran
- Free Pascal
- FreeBASIC
- FutureBasic
- Gambas
- Go
- Groovy
- Haskell
- Haxe
- HicEst
- I
- Icon
- Unicon
- IDL
- Insitux
- J
- Java
- JavaScript
- Jq
- Julia
- Kotlin
- LabVIEW
- Lasso
- Liberty BASIC
- Lisaac
- Logo
- Lua
- M2000 Interpreter
- Maple
- Mathematica
- Wolfram Language
- MATLAB
- Maxima
- MAXScript
- Min
- MiniScript
- MIPS Assembly
- Mirah
- MIRC Scripting Language
- Modula-3
- MUMPS
- Nanoquery
- Nemerle
- NetRexx
- Nim
- Nu
- Objeck
- Objective-C
- OCaml
- Octave
- Odin
- Oz
- PARI/GP
- Pascal
- PascalABC.NET
- PeopleCode
- Perl
- Phix
- PHP
- PicoLisp
- Pike
- PL/I
- PL/SQL
- Plain English
- PowerShell
- Prolog
- PureBasic
- Python
- Quackery
- R
- Racket
- Raku
- RapidQ
- REBOL
- Retro
- REXX
- Ring
- RPL
- Ruby
- Run BASIC
- Rust
- Scala
- Scheme
- Seed7
- Sidef
- Simula
- Smalltalk
- SNOBOL4
- SQL
- SQL PL
- Standard ML
- Swift
- Tcl
- TMG
- Toka
- True BASIC
- UNIX Shell
- Ursa
- VBA
- VBScript
- Vedit macro language
- Visual Basic .NET
- V (Vlang)
- Wren
- Wren-fmt
- XLISP
- XPL0
- Z80 Assembly
- Zig
- Zkl
- Zoea
- Zoea Visual
- GUISS/Omit
- String manipulation
- Pages with too many expensive parser function calls