System Function DR
This function is available in both monadic and dyadic forms.
Contents 
Monadic Function


R is an arbitrary array.  
Z is a numeric scalar which represents the datatype of R. 
The datatypes are encoded with a unique index in the loworder two digits, and (where appropriate) the bits per element in the higherorder digits:
 110: Boolean, one bit per element
 1611: Character, 16 bits per element
 6412: Integer, 64 bits per element
 6413: Floating Point, 64 bits per element (double precision)
 14: Rational, 16 bytes plus two 4 or 8byte pointers plus size of limbs per element
 15: Variableprecision Floating Point, 12 bytes plus one 4 or 8byte pointer plus size of limbs per element
 19: Arithmetic Progression Array, 64 bits each for the offset and multiplier
 20: Heterogeneous, one 4 or 8byte pointer per element
 21: Nested, one 4 or 8byte pointer per element
For example,
⎕DR 1 0 1
110
⎕DR ⌈/⍬
6413
⎕DR 2 64⍴1 — Note this is really an APA, not Boolean
19
⎕DR 2 64⍴1 1 — This one is Boolean because Reshape produces APAs for integer singleton right arguments only
110
Dyadic Function


R is an arbitrary array.  
L is an integer scalar or oneelement vector datatype (see the table above), or a special value (see below).  
Z is R where each of the values are converted to the datatype indicated by L. 
Returned value Z may alternatively be: numeric scalar, vector of numbers, or a character string  depending on what the value of left argument L is.
If the conversion is from a narrower datatype to a wider datatype, there must be exactly enough columns in the right argument to match a multiple of the size of the wider datatype. For example, when converting from character (16bit) to integer (64bit), the last column of the right argument must be a multiple of 4 (= 64/16); otherwise, a LENGTH ERROR is signalled.
In the following example, an 8element character vector (=128 bits) is converted to two 64bit integers (in both NARS2000 32 and 64bit versions integers are stored in 64bits):
6412 ⎕DR 'NARS2000' 23362775258562638 13511005043687474
If the conversion is from a wider datatype to a narrower datatype, the number of values in the result is a multiple of the ratio of the wider datatype to the narrower datatype. For example, when converting from integer (64bit) to character (16bit), the last column in the result is the product of last column of the right argument and 4 (= 64/16).
For example (inverse of the example just above),
⍴⎕←1611 ⎕DR 23362775258562638 13511005043687474 NARS2000 8
Keep in mind how Arithmetic Progression Arrays are created and represented; they can fool both the casual programmer as well as an experienced coder. For example, one might try the following to convert from Boolean to integer:
6412 ⎕DR 2 64⍴1 ⍝ Conversion of an APA to an integer 1 0 2 64
However, this doesn't produce the expected result because this particular right argument is an APA, and not a simple Boolean vector of 1s. That is, under certain circumstances, the reshape primitive creates an APA. In this case, the APA is an array with an offset of 1, a multiplier of 0 and a shape of 2 rows and 64 cols. The usefulness of APA's in reducing data storage and processing times outweighs their sometimes added code complexity or additional insight, which may be required.
On the other hand, this expression:
6412 ⎕DR 2 64⍴1 1 ⍝ Contrast this with the prior example  Boolean vector created here, NOT an APA ¯1 ¯1
produces the expected result because the right argument is not an integervalued singleton (in fact, it is a twoelement vector which is not eligible for conversion to an APA).
Special Values
There are several special values you may use as a left argument to ⎕DR:
The value 0 displays the datatype of the right argument as a text string so you don't need to remember the datatype numbers.
For example,
⎕DR 0 110 0 ⎕DR 0 Boolean (110): 1 bit per element ⎕DR 23 6412 0 ⎕DR 23 24 Integer (6412): 64 bits per element ⎕DR 1.1 6413 0 ⎕DR 1.1 Floating Point (6413): 64 bits per element ⎕DR 'a' 1611 0 ⎕DR 'a' Character (1611): 16 bits per element ⎕DR ⍳12 19 0 ⎕DR ⍳12 Arithmetic Progression Array (19): 64 bit offset + 64 bit multiplier  PV1 0 ⎕dr 1 2 3x Rational (14): arbitrary precision numerator and denominator 0 ⎕dr 1 2 3v VFP (15): variable precision mantissa, 32bit exponent  FPC128 0 ⎕DR 1v64 2v64 VFP (15): variable precision mantissa, 32bit exponent  FPC64 0 ⎕DR 1 2v64 VFP (15): variable precision mantissa, 32bit exponent  FPCMixed 0 ⎕DR ⍳¨⍳9 Nested Array (21): PTR bits per element 0 ⎕DR 'a' 1 Heterogeneous Array (20): PTR bits per element
Note that the storage format for integers (23 24 in the above examples) is 64bits per element and APAs (⍳12) is 64bits for both the offset and multiplier regardless of whether you are running the 32 or 64bit version of NARS2000.
In the last two examples, the reference to PTR means that storage format consists of pointers and is either 32 or 64bits per element in the 32 or 64bit version of NARS2000, respectively.
Many times in programming  for debugging, data scrutiny or other purposes  it is very important to know exactly how the data is represented by the program. ⎕DR or Data Representation is a feature designed to allow close scrutiny of how data is stored in memory and operated on in NARS2000.
Some arrays have properties that may be displayed by this function:
PV0 This array is a Permutation Vector, origin0 PV1 This array is a Permutation Vector, origin1 All2s This array consists of all 2s FPCnnn This array is a VFP and all entries are represented in Precision nnn FPCMixed This array is a VFP whose entries are represented in two or more different precisions The value 1 converts between hexcharacter and floating point computer formats. This argument makes it very useful to view representations of floating point numbers  in order to better understand numeric precisions, program storage formats, debug multiprecision floatingpoint math routines (by NARS developers) or examine perceived floating point issues. Because this function converts between floating point and character format, it is selfinverse.
For example,
⎕PP←99 1 ⎕DR 1.1 3FF199999999999A ⍴1 ⎕DR 1.1 16 1 ⎕DR 1 3FF0000000000000 1 ⎕DR ÷3 3FD5555555555555 1 ⎕DR '3fd',13⍴'5' 0.3333333333333333 1 ⎕DR ¯∞ ∞ FFF0000000000000 7FF0000000000000 1 ⎕DR '7fe',13⍴'f' ⍝ The largest positive number 1.7976931348623157E308 1 ⎕DR '001',13⍴'0' ⍝ The smallest positive number 2.2250738585072014E¯308 1 ⎕DR '801',13⍴'0' ⍝ The largest negative number ¯2.2250738585072014E¯308 1 ⎕DR 'ffe',13⍴'f' ⍝ The smallest negative number ¯1.7976931348623157E308
The value 2 converts between character and 64bit integer. This argument makes it easy to see the representation of integers. Because this function converts between integer and character format, it is selfinverse.
For example,
2 ⎕DR ¯1 FFFFFFFFFFFFFFFF 2 ⎕DR 16⍴'f' ¯1 2 ⎕DR '7',15⍴'f' ⍝ The largest positive integer 9223372036854775807 2 ⎕DR '8',15⍴'0' ⍝ The smallest negative integer ¯9223372036854775808 2 ⎕DR 9223372036854775807 ¯9223372036854775808 7FFFFFFFFFFFFFFF 8000000000000000
The value 3 returns the precision of the right argument array as a simple scalar.
For example,
3 ⎕DR 0 1 1 3 ⎕DR ⍳3 64 3 ⎕DR ÷2 3 64 3 ⎕DR ÷2 3x ∞ 3 ⎕DR 2.3v ⍝ Returns the value of ⎕FPC when the constant was tokenized 128 3 ⎕DR 1v64 64 3 ⎕DR 'a' 0 3 ⎕DR 'a' 1 0 3 ⎕DR ⊂1 2 0
A Word of Caution
This system function allows you to create special numbers we don't support in that no other primitive generates these numbers and the behavior of all other primitives on these numbers is undefined. Examples of such special numbers include Quiet NaNs, Signaling NaNs, Negative Zero, and Denormals. If the system doesn't behave as you expect when using these special numbers, don't be surprised.
For example,
⎕CT←0 ⋄ ⎕PP←99 6413 ⎕DR ¯64↑1 ¯0 QNaN←6413 ⎕DR ¯64↑13⍴1 ⍝ The Real Indefinite (Quiet NaN) where NaN = Not a Number 1 ⎕DR QNaN FFF8000000000000 QNaN=QNaN 0 1 ⎕DR '000fffffffffffff' ⍝ The largest positive denormal 2.225073858507201E¯308 1 ⎕DR '0000000000000001' ⍝ The smallest positive denormal 5E¯324
There is incomplete support for negative zero (¯0) in NARS2000. It may be enabled by setting the second element of ⎕FEATURE to 1, i.e. ⎕FEATURE[2]←1. If you dare to try this concept, please report any problems in the usual manner via the forum, but please understand this feature is not fully supported.
See also System Variable ⎕CT and System Variable ⎕PP.
Note: ⎕DR is available as both a monadic and dyadic form system function, you cannot assign a value to it.
System Variables (A value may be assigned to these except for ⎕DM)  

⎕ALX  ⎕CT  ⎕DM  ⎕DT  ⎕ELX  ⎕FC  ⎕FEATURE  ⎕FPC  ⎕IC  ⎕IO 
⎕LX  ⎕PP  ⎕PR  ⎕PW  ⎕RL  ⎕SA  ⎕WSID  
Niladic System Functions (a value cannot be assigned to these)  
⎕A  ⎕AV  ⎕EM  ⎕ET  ⎕LC  ⎕NNAMES  ⎕NNUMS  ⎕SYSID  ⎕SYSVER  ⎕T 
⎕TC  ⎕TCBEL  ⎕TCBS  ⎕TCESC  ⎕TCFF  ⎕TCHT  ⎕TCLF  ⎕TCNL  ⎕TCNUL  ⎕TS 
⎕WA  
Monadic or dyadic system functions (a value cannot be assigned to these)  
⎕AT  ⎕CR  ⎕DC  ⎕DL  ⎕DR  ⎕EA  ⎕EC  ⎕ERROR  ⎕ES  ⎕EX 
⎕FMT  ⎕FX  ⎕MF  ⎕NAPPEND  ⎕NC  ⎕NCREATE  ⎕NERASE  ⎕NINFO  ⎕NL  ⎕NLOCK 
⎕NREAD  ⎕NRENAME  ⎕NREPLACE  ⎕NRESIZE  ⎕NSIZE  ⎕NTIE  ⎕NUNTIE  ⎕STOP  ⎕TF  ⎕TRACE 
⎕UCS  ⎕VR  
Note that quad functions and variables are case insensitive 