# Guides/Constants

< Guides

J has a rich constant description syntax. J's constant notation is a sublanguage in its own right.

## Useful examples:

`1r3`1/3 exactly (rational number) rational `1.1r3.3`0.3333... floating point approximation of 1.1/3.3=1/3 floating point `1r7`1/7 another exact representation rational `1r7p0`0.142857... = floating point approximation of 1/7 floating point `1p1`π floating point `2r3p1`floating point `180p_1`= degrees in radian floating point `1r180p1`= radians in degree floating point `0j2p1`= exponent coefficient in Fourier transformation complex `_`, infinity floating point `__`, negative infinity floating point `_r1`,`1r0`, extended infinity, compare

`_>10^1000x`

`0`

`1r0>10^1000x`

`1`extended `2b10101010`integer `16baa`same integer `1 0 1 0 1 0`list of bits

## Not so useful examples:

`7e1p_2j3e_2b_9j3x1e8`exercise to the reader `1x0j1p1`If this worked, it would demonstrate Euler's equation (i.e. `_1 = ^ 1p1 * 0j1`), but it doesn't, because 'x' and 'p' are on the same level of the Constant Hierarchy

## Delimited Pseudo Constants

Often it's hard to type in and read large values and in user interface
they use thousand delimited syntax, such as `1,234.56`. The `0&".` monad
handles this nicely. Here are a few examples:

0".'1,000.25' 1000.25 0".'1,000,123' 1000123 0j15":0".'3.14159,26535,89793' 3.141592653589793 0".'1,234 5,678.9' 1234 5678.9 #:0".'2b1000,1000,1000,1000' 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0

## Notes:

- Aside from extended precision numbers (and even in many of those cases), any value you can create using the sublanguage of constants, you can also create using primitives. For example,
`12j14`can be expressed as`12 j. 14`,`12x14`is equivalent to`12 * ^ 14`, and, similarly,`12p14`is identical to`12 * 14 ^~ o. 1`. Rational numbers can be created using extended precision numbers in combination with`%`. Because in-line constants are small, efficiency should not be an issue. And, since the results are identical, choosing between the direct, constant form and the indirect, executed form is a matter of readability and maintainability. This is a matter of PersonalTaste.

- J constants are created with the simplest possible type, regardless of the symbols used create them, so 1.0 is not real; it is not even an integer; it is a boolean. Only extended and rational constants force explicit type conversions.

To demonstrate:

nums =. '1 1.0 1r1 1j0 1p0 1e0 1x0 16b1 1x' require 'strings' (,. ' is '&,"1)&:>/ <@:>"1 (,: datatype@:".&.>) ' ' cut nums 1 is boolean 1.0 is boolean 1r1 is extended 1j0 is boolean 1p0 is boolean 1e0 is boolean 1x0 is boolean 16b1 is boolean 1x is extended

- The semantics of arbitrary width numbers (extended and rationals) are different from the semantics of the fixed-width numbers (which reflect the underlying machine implementation).

16^16 1.84467e19 16^16+0x 18446744073709551616

- Though it isn't spelled out in the language of the Dictionary, some constants with notational mixture form illegal numbers. Example:

`1r1 1x`OK `1j1 1x`Not OK. Probably because J doesn't support extended precision complex numbers (and given the first bullet above, the x forces extended precision, so the intepreter can't default the constant to `1j1 1j0`).`16bffff 1x`Not OK. This makes some sense because an 'x' suffix in a based number is ambiguous. The trailing x could mean "convert to extended precision" or it could mean "the digit 'x' in base N" (all digits are valid in all based numbers, see below). But if the numeric lexer were slightly smarter, this could be resolved.

- When using 'based' constants, be aware that:

- . You cannot use uppercase letters. For example,
`16bFFFF`is an ill formed number - . Digits larger than the base are permissible.
`2b1010 2b2020`and`16bzyxwv`are acceptible numbers; the base portion only specifies the radix, not the interpretation of the digits, which are always evaluted in base 36. - . While the base portion of a constant can be arbitrarily large, the value portion is restricted to using 36 digits (10 numerals + 26 letters), so the notation cannot specify all numbers in bases larger than 36.
- . The Dictionary sentence Moreover, digits with a trailing x denote an extended precision integer is poorly phrased, because
`16b000x`has digits with a trailing x (but is not entirely composed of them), and is not extended -- it's integer. - . Assuming a single, well formed, based constant, the evaluation is:

split =. ( (}.~ >:) ; {.~ ) i.&'b' digits =. '0123456789abcdefghijklmnopqrstuvwxyz'&i.&.> @: split baseN =. #.~&:>/ @: ,&(<10) @: digits baseN '16bffff' 65535

See Parse, Lex, Execute

- J internal types has information on J's internal representation of the various types of numbers (and other data).