# Guides/Constants

< Guides

Jump to navigation
Jump to search
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 interpreter 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 -- this would change the meaning of 2b100 100). 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 acceptable numbers; the base portion only specifies the radix, not the interpretation of the digits, which are always evaluated 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. - Numbers which slightly exceed machine integer limits such as INT_MAX are coerced to the integer limit value rather than being coerced into floating point representation. Thus, on a 64 bit machine,
`16b7fffffffffffffff = 16b800000000000ffff`produces a true result. (Withdrawn in later betas of J903.) - 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).