System Function DR - Revision history

WikiSysop: /* Special Values */

2024-02-18T20:07:55Z

Special Values

← Older revision		Revision as of 16:07, 18 February 2024
Line 219:		Line 219:
	</li>		</li>

	<li><p>The value <apll>3</apll> returns the precision of the right argument array as a simple scalar.</p>		<li><p>The value <apll>3</apll> returns the precision in bits of the right argument array as a simple scalar.</p>

	<p>For example,</p>		<p>For example,</p>

WikiSysop: /* Special Values */

2023-11-20T22:07:23Z

Special Values

← Older revision		Revision as of 18:07, 20 November 2023
Line 126:		Line 126:
	0 ⎕DR ⍳12		0 ⎕DR ⍳12
	Arithmetic Progression Array (19): 64 bit offset + 64 bit multiplier -- PV1		Arithmetic Progression Array (19): 64 bit offset + 64 bit multiplier -- PV1
	0 ⎕dr 1 2 3x		0 ⎕dr 1 2 3<_x/>
	Rational (14): arbitrary precision numerator and denominator		Rational (14): arbitrary precision numerator and denominator
	0 ⎕dr 1 2 3v		0 ⎕dr 1 2 3<_v/>
	VFP (15): variable precision mantissa, 32-bit exponent -- FPC128		VFP (15): variable precision mantissa, 32-bit exponent -- FPC128
	0 ⎕DR 1v64 ~~2v64~~		0 ⎕DR 1v64 2<_v/>64
	VFP (15): variable precision mantissa, 32-bit exponent -- FPC64		VFP (15): variable precision mantissa, 32-bit exponent -- FPC64
	0 ⎕DR 1 ~~2v64~~		0 ⎕DR 1 2<_v/>64
	VFP (15): variable precision mantissa, 32-bit exponent -- FPC-Mixed		VFP (15): variable precision mantissa, 32-bit exponent -- FPC-Mixed
	0 ⎕DR ⍳¨⍳9		0 ⎕DR ⍳¨⍳9
Line 219:		Line 219:
	</li>		</li>

	<li><p>The value <apll>3</apll> returns the precision of the right argument array as a simple scalar.</p>		<li><p>The value <apll>3</apll> returns the precision of the right argument array as a simple scalar.</p>

	<p>For example,</p>		<p>For example,</p>
Line 230:		Line 230:
	3 ⎕DR ÷2 3		3 ⎕DR ÷2 3
	64		64
	3 ⎕DR ÷2 3x		3 ⎕DR ÷2 3<_x/>
	∞		∞
	3 ⎕DR 2.3v ⍝ Returns the value of ⎕FPC when the constant was tokenized		3 ⎕DR 2.3<_v/> ⍝ Returns the value of ⎕FPC when the constant was tokenized
	128		128
	3 ⎕DR ~~1v64~~		3 ⎕DR 1<_v/>64
	64		64
	3 ⎕DR 'a'		3 ⎕DR 'a'
Line 242:		Line 242:
	3 ⎕DR ⊂1 2		3 ⎕DR ⊂1 2
	0		0
			</pre></apll>

			<li><p>The value <apll>4</apll> returns the numerator and denominator of a right argument Rational array as a Rational integer array whose shape is <apll>2,{rho}R</apll>.</p>

			<p>For example,</p>

			<apll><pre> ⍴⎕←4 ⎕dr 1<_r/>3
			1 3
			2
			⍴⎕←4 ⎕dr ,1<_r/>3
			1
			3
			2 1
			⍴⎕←4 ⎕dr 1<_r/>3 3<_r/>7
			1 3
			3 7
			2 2
	</pre></apll>		</pre></apll>
	</li>		</li>

	</ul>		</ul>

WikiSysop: /* Monadic Function */

2023-11-20T20:24:53Z

Monadic Function

← Older revision		Revision as of 16:24, 20 November 2023
Line 2:		Line 2:
	==Monadic Function==		==Monadic Function==
	{{BoxStart\|<apll>Z←⎕DR R</apll>		{{BoxStart\|<apll>Z←⎕DR R</apll>
	\|returns the ~~data~~ representation of <apll>R</apll>.}}		\|returns the internal representation of <apll>R</apll>.}}
	{{BoxLine \|<apll>R</apll> is an arbitrary array.}}		{{BoxLine \|<apll>R</apll> is an arbitrary array.}}
	{{BoxEnd \|<apll>Z</apll> is a numeric scalar which represents the datatype of <apll>R</apll>.}}		{{BoxEnd \|<apll>Z</apll> is a numeric scalar which represents the datatype of <apll>R</apll>.}}
	<br />		<br />

	<p>The ~~datatypes are encoded with~~ a unique index ~~in the low~~-order two digits~~, and~~ (where appropriate) the ~~bits per element in~~ the ~~higher-order digits~~:</p>		<p>The low-order two digits of the result encode the internal representation as a unique index for each category. The high-order two digits of the result encode either the number of bits per element (where appropriate), or for Hypercomplex numbers, the internal representation of the coefficients:</p>

	*<apll> 110</apll>: Boolean, one bit per element		*<apll> 110</apll>: Boolean, one bit per element
Line 30:		Line 30:
	*<apll>  20</apll>: Heterogeneous, one 4- or 8-byte pointer per element		*<apll>  20</apll>: Heterogeneous, one 4- or 8-byte pointer per element
	*<apll>  21</apll>: Nested, one 4- or 8-byte pointer per element		*<apll>  21</apll>: Nested, one 4- or 8-byte pointer per element
			*<apll>  22</apll>: Real (one-dimensional) Ball Arithmetic
			*<apll>2216</apll>: Complex (two-dimensional) Ball Arithmetic
			*<apll>2217</apll>: Quaternion (four-dimensional) Ball Arithmetic
			*<apll>2218</apll>: Octonion (eight-dimensional) Ball Arithmetic

	<p>For example,</p>		<p>For example,</p>

Paul Robinson: Clarify pointz

2019-10-02T08:54:56Z

Clarify pointz

← Older revision		Revision as of 04:54, 2 October 2019
Line 38:		Line 38:
	⎕DR ⌈/⍬		⎕DR ⌈/⍬
	6413		6413
	⎕DR 2 64⍴1 — Note ~~this is really an APA, not Boolean~~		⎕DR 2 64⍴1 — Note [1]
	19		19
	⎕DR 2 64⍴1 1 — ~~This one is Boolean because Reshape produces APAs for integer singleton right arguments only~~		⎕DR 2 64⍴1 1 — Note [2]
	110		110
	</pre>		</pre>
			<sup>[1]</sup> This is really an APA, not Boolean <br />
			<sup>[2]</sup> This one is Boolean because Reshape produces APAs for integer singleton right arguments only

	==Dyadic Function==		==Dyadic Function==

WikiSysop at 05:12, 16 April 2018

2018-04-16T05:12:45Z

← Older revision		Revision as of 01:12, 16 April 2018
Line 33:		Line 33:
	<p>For example,</p>		<p>For example,</p>

	<~~apll~~>~~      ~~⎕DR 1 0 1~~<br />~~110~~<br />~~		<pre>
	~~      ~~⎕DR ⌈/⍬~~<br />~~6413~~<br />~~		⎕DR 1 0 1
	~~      ~~⎕DR 2 64⍴1~~</apll>~~ — Note this is really an APA, not Boolean~~<apll><br />~~19~~<br />~~		110
	~~      ~~⎕DR 2 64⍴1 1~~</apll>~~ — This one is Boolean because Reshape produces APAs for integer singleton right arguments only~~<apll><br />~~110~~<br /></apll>~~		⎕DR ⌈/⍬
	<~~br /><br~~ />		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
			</pre>

	==Dyadic Function==		==Dyadic Function==

WikiSysop: /* Monadic Function */

2017-06-03T19:13:00Z

Monadic Function

@@ Line 15: / Line 15: @@
 *<apll>&nbsp;&nbsp;14</apll>:  Rational, 16 bytes plus two 4- or 8-byte pointers plus size of limbs per element
 *<apll>&nbsp;&nbsp;15</apll>:  Variable-precision Floating Point, 12 bytes plus one 4- or 8-byte pointer plus size of limbs per element
 *<apll>&nbsp;&nbsp;19</apll>:  Arithmetic Progression Array, 64 bits each for the offset and multiplier
 *<apll>&nbsp;&nbsp;20</apll>:  Heterogeneous, one 4- or 8-byte pointer per element

WikiSysop: /* Dyadic Function */

2016-12-21T21:22:53Z

Dyadic Function

Show changes

WikiSysop: /* Special Values */

2016-12-21T20:33:31Z

Special Values

Show changes

Robert Wallick: /* Dyadic Function */ expansion, correction

2015-08-22T01:11:00Z

Dyadic Function: expansion, correction

← Older revision		Revision as of 21:11, 21 August 2015
Line 38:		Line 38:

	<apll>		<apll>
	6412 ⎕DR 'NARS2000'</apll> — Eight 16-bit characters (=128 bits) converts to <u>two 64-bit integers</u>:<apll><br />		6412 ⎕DR 'NARS2000'</apll> — Eight 16-bit characters (=128 bits) converts to <u>two 64-bit integers</u> (in both NARS2000 32-bit AND 64-bit exe's since <big>L=6412</big>):<apll><br />
	23362775258562638 13511005043687474<br />		23362775258562638 13511005043687474<br />
	</apll>		</apll>
Line 59:		Line 59:
	</apll>		</apll>

	<p>However, this doesn't produce the expected result because this particular right argument is an <big>APA</big>, and <u>not</u> a simple Boolean vector of 1's. That is, under certain circumstances, the reshape primitive creates an APA. In this case, the APA is an array with an offset of <apll>1</apll>, a multiplier of <apll>0</apll> and a shape of <apll>2</apll> rows and <apll>64</apll> cols. The usefulness of ~~APS~~'s in reducing data storage and processing times outweighs their sometimes added code complexity or additional insight, which may be required.</p>		<p>However, this doesn't produce the expected result because this particular right argument is an <big>APA</big>, and <u>not</u> a simple Boolean vector of 1's. That is, under certain circumstances, the reshape primitive creates an APA. In this case, the APA is an array with an offset of <apll>1</apll>, a multiplier of <apll>0</apll> and a shape of <apll>2</apll> rows and <apll>64</apll> 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.</p>

	<p>On the other hand, this expression:</p>		<p>On the other hand, this expression:</p>
Line 97:		Line 97:
	76 ⍝ again dyadic ⎕DR results in a string, this time of length 76		76 ⍝ again dyadic ⎕DR results in a string, this time of length 76
	</pre>		</pre>
	Note in the above that iota-12 in System Function call '''0 ⎕DR ⍳12''' - ~~was run~~ using ~~the~~ '''64-bit NARS ~~version~~''', hence the 64-bit offset and 64-bit multiplier. ~~Had it been run in '''32~~-bit ~~NARS'''~~, ~~it would have returned 32-bit signatures~~.		<p>Note in the above that iota-12 in System Function call '''0 ⎕DR ⍳12''' - runs similarly using both '''64-bit AND 32-bit NARS versions''', hence the 64-bit offset and 64-bit multiplier. This is because integer APAs are processed using 64-bit formats. Again, if ever there is any doubt or a need to precisely determine formats, use ⎕DR with its correct syntax, arguments.</p><br>

	Many times in programming for debugging, data scrutiny or other purposes~~: It~~ is very important to know <u>exactly how the data is represented by the program</u>. ⎕DR or Data Representation is a feature designed to allow close scrutiny of how data is stored in memory and operated on in NARS.		<p>Many times in programming - for debugging, data scrutiny or other purposes - it is very important to know <u>exactly how the data is represented by the program</u>. ⎕DR or Data Representation is a feature designed to allow close scrutiny of how data is stored in memory and operated on in NARS.</p><br>

	<p>Some arrays have properties that may be displayed by this function:</p>		<p>Some arrays have properties that may be displayed by this function:</p>
Line 135:		Line 135:
	3FF199999999999A    ⍝ note the hexadecimal char representation of 1.1 is shown at left<br />		3FF199999999999A    ⍝ note the hexadecimal char representation of 1.1 is shown at left<br />
	⍴1 ⎕DR 1.1<br />		⍴1 ⎕DR 1.1<br />
	16                  ⍝ length of floating pt num 1.1 hex repr = 16 hex-chars = 64-bit-NARS<br />		16                  ⍝ length of floating pt num 1.1 hex repr = 16 hex-chars = both 64-bit and 32-bit NARS<br />
	1 ⎕DR '3fd',13⍴'5'<br />		1 ⎕DR '3fd',13⍴'5'<br />
	0.3333333333333333<br />		0.3333333333333333<br />
Line 191:		Line 191:
	</apll>		</apll>
	<br/>		<br/>
			See also '''[[System_Variable_CT\|System Variable ⎕CT]]''' and '''[[System_Variable_PP\|System Variable ⎕PP]]'''.<br>
	{{SFDM\|DR}}		{{SFDM\|DR}}

Robert Wallick: /* Dyadic Function */

2015-08-21T17:16:29Z

Dyadic Function

← Older revision		Revision as of 13:16, 21 August 2015
Line 33:		Line 33:
	{{BoxLine\|<apll>L</apll> is an integer scalar or one-element vector datatype (see the table above), or a special value (see below).}}		{{BoxLine\|<apll>L</apll> is an integer scalar or one-element vector datatype (see the table above), or a special value (see below).}}
	{{BoxEnd\|<apll>Z</apll> is <apll>R</apll> where each of the values are converted to the datatype indicated by <apll>L</apll>.}}		{{BoxEnd\|<apll>Z</apll> is <apll>R</apll> where each of the values are converted to the datatype indicated by <apll>L</apll>.}}
	Returned value '''Z''' may alternatively be: numeric scalar, vector of numbers, or a character string - depending on what the value of ~~the laft~~ argument(L) was.<br /><br>		Returned value <big>'''Z'''</big> may alternatively be: numeric scalar, vector of numbers, or a character string - depending on what the value of left argument <big>'''L'''</big> was.<br /><br>

	<p>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 (16-bit) to integer (64-bit), the last column of the right argument must be a multiple of 4 (= 64/16); otherwise, a <apll>LENGTH ERROR</apll> is signalled.</p>		<p>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 (16-bit) to integer (64-bit), the last column of the right argument must be a multiple of 4 (= 64/16); otherwise, a <apll>LENGTH ERROR</apll> is signalled.</p>
Line 52:		Line 52:
	</apll>		</apll>

	<p>Keep in mind how [[APA\|Arithmetic Progression Arrays]] are created and represented as they can fool ~~you~~. For example, ~~you~~ might try the following to convert from Boolean to integer:</p>		<p>Keep in mind '''<u>how</u> [[APA\|Arithmetic Progression Arrays]]''' are <u>created and represented</u>; 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:</p>

	<apll>		<apll>
	6412 ⎕DR 2 64⍴1<br />		6412 ⎕DR 2 64⍴1     ⍝ APA created<br />
	1 0 2 64<br />		1 0 2 64<br />
	</apll>		</apll>

	<p>However, this doesn't produce the expected result because this particular right argument is an APA, not a Boolean vector. That is, under certain circumstances, the reshape primitive creates an APA. In this case, the APA is an array with an offset of <apll>1</apll>, a multiplier of <apll>0</apll> and a shape of <apll>2 64</apll>.</p>		<p>However, this doesn't produce the expected result because this particular right argument is an <big>APA</big>, and <u>not</u> a simple Boolean vector of 1's. That is, under certain circumstances, the reshape primitive creates an APA. In this case, the APA is an array with an offset of <apll>1</apll>, a multiplier of <apll>0</apll> and a shape of <apll>2</apll> rows and <apll>64</apll> cols. The usefulness of APS's in reducing data storage and processing times outweighs their sometimes added code complexity or additional insight, which may be required.</p>

	<p>On the other hand, this expression</p>		<p>On the other hand, this expression:</p>

	<apll>		<apll>
	6412 ⎕DR 2 64⍴1 1<br />		6412 ⎕DR 2 64⍴1 1   ⍝ contrast to prior example - Boolean vec created here, NOT an APA<br />
	¯1<br />		¯1<br />
	¯1<br />		¯1<br />
	</apll>		</apll>

	<p>produces the expected result because the right argument is ~~now~~ Boolean.</p>		<p>produces the expected result because the right argument is "right upon moment of vector '''1 1''' creation" - Boolean.</p>

	===Special Values===		===Special Values===