## How to convert between numbers and character representations of numbers

Sometimes we have the character representation of a number but we want to work with number represented whereas, conversely, sometimes we wish to convert a number to characters. Representing numbers in bases other than 10 can be done using numeric or character vectors; see J Phrases for Changing Data Types

### Number to Character Using Format in Newer and Older Form

Use one of the variants of the verb Format (8!:0) to convert from a number to its character equivalent:

```   fmt=: 8!:0
fmt 1 _2 3.14 4e_3
+-+--+----+-----+
|1|-2|3.14|0.004|
+-+--+----+-----+```

This boxes the results. However,

```   fmt2=: 8!:2
fmt2 1 22 333 4444
1223334444```

does not.

The foreign Format (8!:0) takes an optional left argument of a format string - see the details here. One common use of a format string is to pad numbers with leading zeros, e.g.

```   'r<0>4.0' 8!:0 i.5
+----+----+----+----+----+
|0000|0001|0002|0003|0004|
+----+----+----+----+----+```

A general function like this

`lead0s=: 13 : '(]`> @. (1=[:#,))(''r<0>'',(":x),''.0'') 8!:0 y'`

```   3 lead0s i.5
+---+---+---+---+---+
|000|001|002|003|004|
+---+---+---+---+---+```

Oleg Kobchenko recommends using take with fill {.!.'0' as the best generic method for leading zero padding:

```   _3{.!.'0' &.> (8!:0) i.5
+---+---+---+---+---+
|000|001|002|003|004|
+---+---+---+---+---+```

Or another yet more generic one:

```  zeropad=: (-@[ {. [: ": 10&^@[ + ])"0
00123
01234
+--+-----+
|23|01234|
+--+-----+```

None of these methods account for negative numbers but that can be done as a separate step if required, perhaps using and adverb like this:

```   leadneg=: 1 : '(u |y),~''-''#~_1=*y'
000
-001
-002

+-----+------+------+
|00000|-00001|-00002|
+-----+------+------+```

### Foreign Format (8!:n)

From the Dictionary definition of the variants of this verb:

```[x] 8!:0 y Format. Format array y according to format phrases x . Each formatted number is in a box.

[x] 8!:1 y Format1. As in x 8!:0 y , but y has rank at most 2 and each formatted column is in a box.

[x] 8!:2 y Format2. As in x 8!:0 y , but y has rank at most 2 and the result is a literal table. ```

So,

```   fmt1=: 8!:1
fmt1 i.2 3
+-+-+-+
|0|1|2|
|3|4|5|
+-+-+-+
fmt2 i.2 3
012
345```

### (Older) Number to Character (":)

For older versions of J in which 8!:n is not available, one can use the older, primitive version of Format (":) :

```   ": 1 22 33.3               NB. Monad
1 22 33.3
'Numbers: ',": 1 22 33.3   NB. Show that result is character
Numbers: 1 22 33.3```

An optional left argument specifies a formatting string using complex numbers where the real part determines the length of the formatted number and the imaginary part determines the number of digits after the decimal point:

```   'Formatted numbers: ',6j1": 1 22 33.3
Formatted numbers:    1.0  22.0  33.3```

### Format Numbers as Character, Specifying Number of Digits to Display (RjI ":)

The primitive Format also takes a complex number as the optional left argument to specify total length of the resulting string (real part) and number of digits after the decimal point (imaginary part). For example, the value of the mathematical constant "e" shown to the limits of precision (specified by 9!:10):

```   ^1
2.7182818```

```   19j17 ": ^1
2.71828182845904510```

Asking for more precision than we really have gives spurious trailing zeroes:

```   29j27 ": ^1
2.718281828459045100000000000```

Allowing for too few digits before (and including) the decimal point:

```   16j15 ": ^1
****************```

### Character to Number (".)

Use the verb Numbers (".) to convert from a character string to equivalent number. For example,

```   ". '1 2 35'
1 2 35```

To see that the result is numeric:

```   100+". '1 2 35'
101 102 135```

The dyadic form of this verb may be faster and it allows a default value to be substituted for any string not convertible to a valid number:

```   _99 ".&>'123';'bad';'456';'nutherbad';'789'  NB. Substitute "_99" for non-numbers
123 _99 456 _99 789

\$nn=. '0123456789   '
13
many=. nn{~?1e7\$#nn
2.2764244
6!:2 '_.".many'     NB. Dyad using "indeterminate" substitution...
1.3662863
(_.".many)-:".many
1```

Converting numbers from an Excel spreadsheet has its own dangers; see caveats about numbers from Excel.

Note that the monadic form of "., called "Do", is a general verb for running a J phrase represented as a character vector, i.e.

```   ". '1+2'
3
0 6 9 + 48 49 29
48 55 38

NB. Random equations:
eqn,' = ',": ". eqn=. (":?10),((]{~[:?#)'+-*%'),":?100
4%58 = 0.068965517
eqn,' = ',": ". eqn=. (":?10),((]{~[:?#)'+-*%'),":?100
9+30 = 39
eqn,' = ',": ". eqn=. (":?10),((]{~[:?#)'+-*%'),":?100
5*42 = 210```

This is why something like this

```   ". '1 -2 -3'
2```

might be puzzling until you understand that it is evaluating the J expression to perform successive subtractions, equivalent to

```   -/1 2 3
2```

whereas the following may have been intended:

```   ". '1 _2 _3'
1 _2 _3```

See also the following "How to convert negative numbers..."] for this specific problem.

## How to convert negative numbers between J and other applications

Negative numbers in J are preceded by the underscore character "_" whereas most applications use the dash "-" for this purpose. So, "_2" in J would be represented as "-2" in, say, Excel. A commonly-asked question is how to convert from one representation to the other.

### Negative Representations to J Numbers

Typically, we use the dyadic verb Numbers (".) to convert from, e.g. -2 to _2, i.e.

```   _. ". &> '-2';'1e-2'
_2 0.01```

The left argument "_." is a number (Indeterminate in this case) to substitute for any non-numeric string. Indeterminate seems appropriate to use for a value we cannot figure out, but any other numeric value can be used. For example,

```   12345 ". &> '-3';'nonnumeric';'3e-3';'oops';'-3e-3'
_3 12345 0.003 12345 _0.003```

or

```   _99.9 ". &> '-3';'nonnumeric';'3e-3';'oops';'-3e-3'
_3 _99.9 0.003 _99.9 _0.003```

### From J Number to Character Representation Suitable for Another Application: Underscore to Minus

Typically, we use the verb Format (8!:0) to convert from J to a more standard representation:

```   fmt=: 8!:0
fmt 1 _2 3.14 4e_3
+-+--+----+-----+
|1|-2|3.14|0.004|
+-+--+----+-----+```

Notice that fmt is smart enough to box its results; this is necessary because it must convert numbers into character strings.

The older version of Format (":) doesn't do as much but works with older versions of J; see the preceding section.

If you use this older version, you have to handle the negative sign replacement separately. Something like this would work for the simplest case:

```   cm=: ('_',a.)&i. { ('-',a.)"_
cm ": -12.34
-12.34
'A negative number: ','.',~cm ": -12.34
A negative number: -12.34.
cm ": -i.5
0 -1 -2 -3 -4```