From J Wiki
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


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,234 5,678.9'
1234 5678.9
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0


  • 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).
  • 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:
  1. You cannot use uppercase letters. For example, 16bFFFF is an ill formed number
  2. 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.
  3. 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.
  4. 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.
  5. 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.)
  6. Assuming a single, well formed, based constant, the evaluation is:
   split  =. (  (}.~ >:) ; {.~  )  i.&'b'
   digits =. '0123456789abcdefghijklmnopqrstuvwxyz'&i.&.>  @:  split
   baseN  =. #.~&:>/  @:  ,&(<10)  @:  digits

   baseN '16bffff'
   See Parse, Lex, Execute
  • J internal types has information on J's internal representation of the various types of numbers (and other data).