NARS2000 - User contributions [en]

Symbol Match

2019-10-17T12:30:18Z

Paul Robinson: correct categories

__NOTOC__
<h1> {match} — Depth or Match or Multiset Identical — Keystroke ALT+SHIFT+1 — Character 8801</h1>

[[File:APLKB-Match.png]]
==Usage==
==Example==

{{Stub}}
{{Article footer|4|M}}
[[Category:Boolean operators]]
[[Category:Dyadic operators]]

Keyboard

2019-10-17T12:22:47Z

Paul Robinson:

These are the keyboard positions used by NARS2000. Hover over a link to see the name of the symbol, click on the link to go to the page defining the symbol. Also see [http://www.sudleyplace.com/APL/Keyboard.ahtml keyboard] and '''[[APL_Font|APL Font default keyboard]]'''. '''Note;;''' Not al symbols which can be entered from the keybiard are valid operators im APL or in NARS2000.

{| class="wikitable" style="font-size: 200%;" width="80%" align="center"
|-
||ALT+Shift
||[[Symbol Comma Bar|⍪]]
||[[Symbol Match|≡]]
||[[Symbol Not Match|≢]]
||[[Symbol Grade Down|⍒]]
||[[Symbol Grade Up|⍋]]
||[[Symbol Rotate|⌽]]
||[[Symbol Circle Slope|⍉]]
||[[Symbol Circle Bar|⊖]]
||[[Symbol Log|⍟]]
||[[Symbol Nor|⍱]]
||[[Symbol Nand|⍲]]
||[[Symbol Factorial|!]]
||[[Symbol Domino|⌹]]
|-
||ALT
||[[Diamond|⋄]]
||[[Symbol Dieresis|¨]]
||[[Symbol Overbar|¯]]
||[[Symbol Less Than|<]]
||[[Symbol Less Than or Equal|≤]]
||[[Symbol Equal|=]]
||[[Symbol Greater Than or Equal|≥]]
||[[Symbol Greater Than|>]]
||[[Symbol Not Equal|≠]]
||[[Symbol Down Caret|∨]]
||[[Symbol And|∧]]
||[[Symbol Times|×]]
||[[Symbol Divide|÷]]
|-
||Shift
||[[Symbol Not|~]]
||[[Symbol Factorial|!]]
||@
||#
||$
||%
||^
||&
||*
||[[Symbol Parenthesis|(]]
||[[Symbol Parenthesis|)]]
||[[Symbol Underbar|_]]
||[[Symbol Plus|+]]
|-
||Key
||`
||1
||2
||3
||4
||5
||6
||7
||8
||9
||0
||[[Symbol Minus|-]]
||[[Symbol Equal|=]]
|| (backspace)
|-
|colspan=15|
|-
||ALT+Shift
|colspan=3|
||[[Symbol Find|⍷]]
||[[Symbol Root|√]]
||[[Symbol Commute|⍨]]
|colspan=2|
||[[Symbol Iota Underbar|⍸]]
||[[⍥]]
||[[⍣]]
||[[Symbol Quote Quad|⍞]]
||[[Symbol Zilde|⍬]]
||[[Symbol Lev|⊣]]
|-
||ALT
||
||[[Symbol Query|?]]
||[[Special Symbols|⍵]]
||[[Symbol Epsilon|∊]]
||[[Symbol Rho|⍴]]
||[[Symbol Not|∼]]
||[[Symbol Take|↑]]
||[[Symbol Drop|↓]]
||[[Symbol Iota|⍳]]
||[[Symbol Jot|○]]
||[[Symbol Pi|π]]
||[[Symbol Assign|←]]
||[[Symbol Goto|→]]
||[[Symbol Dex|⊢]]
|-
||SHIFT
||
||Q
||W
||E
||R
||T
||Y
||U
||I
||O
||P
||{
||}
||[[Symbol Mod||]]
|-
||Key
||(Tab)
||q
||w
||e
||r
||t
||y
||u
||i
||o
||p
||[[Symbol Brace|[]]
||[[Symbol Brace|]]]
||[[Symbol Slope|\]]
|-
|colspan=15|
|-
||ALT+Shift
|Colspan=2|
||[[Symbol Section|§]]
|colspan=2|
||[[Symbol Dieresis Del|⍢]]
||[[Special Symbols|⍙]]
||[[Symbol Dieresis Jot|⍤]]
||
||[[Symbol Squad|⌷]]
|-
||ALT
||
||[[Special Symbols|⍺]]
||[[Symbol Ceiling|⌈]]
||[[Symbol Floor|⌊]]
||[[Symbol Infinity|∞]]
||[[Del|∇]]
||[[Special Symbols|∆]]
||[[Symbol Jot|∘]]
||[[Symbol Quote|']]
||[[Symbol Quad|⎕]]
||[[Symbol Execute|⍎]]
||[[Symbol Format|⍕]]
|-
||Shift
||
||A
||S
||D
||F
||G
||H
||J
||K
||L
||[[Symbol Colon|:]]
||"
|-
||Key
||(Caps Lock)
||a
||s
||d
||f
||g
||h
||j
||k
||l
||[[Symbol Semicolon|;]]
||[[Symbol Quote|']]
|colspan=2|(enter)
|-
|colspan=15|
|-
||ALT+Shift
||
||[[Symbol Left Shoe Underbar|⊆]]
||[[Symbol Right Shoe Underbar|⊇]]
|colspan=3|
||[[Symbol Dieresis Down Tack|⍡]]
||[[Symbol Stile Tilde|⍭]]
|colspan=2|
||[[Symbol Circle Middle Dot|⊙]]
|-
||ALT
||
||[[Symbol Left Shoe|⊂]]
||[[Symbol Right Shoe|⊃]]
||[[Symbol Up Shoe|∩]]
||[[Symbol Down Shoe|∪]]
||[[Symbol Base Value|⊥]]
||[[Symbol Represent|⊤]]
||[[Symbol Multiset|⍦]]
||[[Lamp|⍝]]
||[[Symbol Slope Bar|⍀]]
||[[Symbol Slash Bar|⌿]]
|-
||Shift
||
||Z
||X
||C
||V
||B
||N
||M
||[[Symbol Less Than|<]]
||[[Symbol Greater Than|>]]
||[[Symbol Query|?]]
|-
||Key
|(Shift)
||z
||x
||c
||v
||b
||n
||m
||[[Symbol Comma|,]]
||[[Symbol Dot|.]]
||[[Symbol Slash|/]]
||(Shift)
|}

{{Article footer}}

Symbol Domino

2019-10-16T16:50:06Z

Paul Robinson: Paul Robinson moved page Symbol Domino to Domino: Page is of sufficient quality to be upgradwd to standalone sympbol name alone

#REDIRECT [[Domino]]

Domino

2019-10-16T16:50:06Z

Paul Robinson: Paul Robinson moved page Symbol Domino to Domino: Page is of sufficient quality to be upgradwd to standalone sympbol name alone

__NOTOC__
<h1> {domino} — Matrix Inverse or Division — Keystroke ALT+SHIFT+= — Character 9017 or 0x2339</h1>
Note: The symbol is created by ALT+SHIFT+=; ALT+= will produce [[Symbol Divide|Divide]] <big>(<big>'''{divide}'''</big>)</big> 
'''Caution:''' Be careful not to confuse this symbol, which is <apll>⌹</apll>, with <apll>⍠</apll> which is [[Variant]].

[[File:APLKB-Domino.png]]
==Usage==

See also '''[[Matrix_Inverse/Divide]]'''.

==Examples==
<big> {domino} Monadic Example - Matrix Inverse for a square matrix:
<pre>
Z ⍝Variable and matrix Z has 3 rows and 3 columns of numbers, as follows:
1 2 3
0 1 4
5 6 0
⌹Z ⍝The mathmatical inverse of matrix Z (domino Z) is also a 3-row by 3-col numeric matrix, as follows:
¯24 18 5
20 ¯15 ¯4
¯5 4 1
</pre>
{domino} Dyadic Example - Matrix Division - Least Squares Curve Fitting - Multiple Regression using Non-Square Data Matrix:
<pre>
⍴Homes ⍝Global variable Homes is a 23 row by 8 column matrix:
23 8
Homes ⍝The first row of variable/matrix Homes has nested column headers, with 22 data rows:
⍝Col#'s 1 2 3 4 5 6 7 8
Property SqFt #Bedrooms #FullBaths #HalfBaths YrsAgoBuilt Price Predicted Price ⍝Note: Predicted Price col(8) is not yet calculated!
A 2149 3 2 1 15 469.9 0
B 2410 4 3 1 13 523.5 0
C 2530 4 3 0 12 535 0
D 2502 3 2 0 12 569.999 0
E 2600 5 2 1 17 588 0
F 2586 4 3 1 6 589 0
G 2836 3 2 1 12 599.9 0
H 3300 4 2 1 10 615 0
I 3000 4 3 0 11 659 0
J 2723 3 2 1 12 665 0
K 2800 4 3 1 18 729 0
L 3700 5 3 1 4 767 0
M 3900 4 3 1 19 799.9 0
N 3840 6 4 1 6 945 0
O 2185 3 2 0 12 515 0
P 2600 4 3 0 12 579.5 0
Q 4220 5 3 1 18 645.9 0
R 2136 3 2 0 14 505 0
S 2530 3 2 1 13 539.9 0
T 2724 3 2 0 12 634.9 0
U 2896 4 3 0 7 750 0
V 3835 3 3 1 6 982.5 0

⍝Note just below that because the first row of Homes has column headers(text) - they must be dropped from ⌹'s least-squares data fit.
RegrCoeffs←(1↓Homes[;7])⌹1,(1 0↓Homes[;2 3 4 5 6]) ⍝Calc regr. coeff's using Home Prices(col 7, dep var Y) vs. all indep vars(X's, cols 2-6)
⍴RegrCoeffs ⍝Note '⌹1,' just above means add extra coeff. for Y-intercept; plus cols(2-6)=5 indep X-type vars; RegrCoeffs has 6 elements.
6
RegrCoeffs
234.9773005 0.1495539775 ¯41.70990009 80.27420326 16.19671155 ¯7.019567895

Homes[1+⍳22;8]←(1,Homes[1+⍳22;2 3 4 5 6])+.×RegrCoeffs ⍝Use inner product +.× to calc predicted prices for 22 data rows, place in col 8.

Homes ⍝The following is what variable Homes looks like; with Predicted Prices calculated and inserted back into matrix Homes:
Property SqFt #Bedrooms #FullBaths #HalfBaths YrsAgoBuilt Price Predicted Price
A 2149 3 2 1 15 469.9 502.6906976
B 2410 4 3 1 13 523.5 594.3277247
C 2530 4 3 0 12 535 603.0970583
D 2502 3 2 0 12 569.999 560.3452438
E 2600 5 2 1 17 588 472.6806055
F 2586 4 3 1 6 589 669.7862
G 2836 3 2 1 12 599.9 626.4929838
H 3300 4 2 1 10 615 668.2152651
I 3000 4 3 0 11 659 680.4069957
J 2723 3 2 1 12 665 609.5933844
K 2800 4 3 1 18 729 617.5559364
L 3700 5 3 1 4 767 808.7185666
M 3900 4 3 1 19 799.9 775.0457438
N 3840 6 4 1 6 945 854.1812909
O 2185 3 2 0 12 515 512.9366329
P 2600 4 3 0 12 579.5 613.5658367
Q 4220 5 3 1 18 645.9 788.2126844
R 2136 3 2 0 14 505 491.5693522
S 2530 3 2 1 13 539.9 573.7098988
T 2724 3 2 0 12 634.9 593.5462268
U 2896 4 3 0 7 750 692.9316536
V 3835 3 3 1 6 982.5 898.289018
</pre>
</big>

{{Article footer|2|Domino}}
[[Category:Monadic operators]][[Category:Dyadic operators]]

Domino

2019-10-16T16:42:02Z

Paul Robinson: explain & add cat

Matrix Inverse/Divide

2019-10-16T16:28:54Z

Paul Robinson: t/c

'''Caution:''' Be careful not to confuse this symbol, which is <apll>⌹</apll>, with <apll>⍠</apll> which is [[Variant]].
<hr /><table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td>
<table border="0" cellpadding="5" cellspacing="0" summary="">
<tr>
<td valign="top"><apll>Z←⌹R</apll></td>
<td></td>
<td></td>
<td>returns the inverse of the right argument.</td>
</tr>
</table>
</td>
</tr>
<tr>
<td><apll>R</apll> is a numeric scalar, vector or matrix; otherwise signal a <apll>RANK ERROR</apll>.</td>
</tr>
<tr>
<td><apll>Z</apll> is a numeric array of rank <apll>⍴⍴R</apll>, and shape <apll>⌽⍴R</apll>.</td>
</tr>
</table>
 
This feature implements matrix inversion on '''Boolean''', '''integer''', or '''floating point''' arguments using [http://www.gnu.org/software/gsl/manual/html_node/Singular-Value-Decomposition.html Singular Value Decomposition]. In particular, this means that any numeric array meeting the rank and shape requirements above is invertible.

Matrix inverse (<apll>⌹R</apll>) and matrix division (<apll>L⌹R</apll>) on '''Rational''', '''VFP''', or '''Ball''' arguments each have two limitations above and beyond that of normal conformability:
<ul>
<li>for a '''square''' (<apll>=/⍴R</apll>) right argument that it be non-singular, and</li>
<li>for an '''overdetermined''' (<apll>>/⍴R</apll>) or '''underdetermined''' (<apll></⍴R</apll>) right argument that the symmetric matrix <apll>(⍉R)+.×R</apll> be non-singular.</li>
</ul>
These limitations are due to the algorithm ([http://en.wikipedia.org/wiki/Gauss%E2%80%93Jordan_elimination Gauss-Jordan Elimination]) used to implement Matrix Inverse/Divide on Rational and VFP numbers.

Overdetermined matrices are evaluated equivalently to the expression <apll>(⌹(⍉R)+.×R)+.×⍉R</apll>.
Underdetermined matrices are evaluated equivalently to the expression <apll>(⍉R)+.×⌹R+.×⍉R</apll>.

For example,

<apll><pre>
⌹3 3{rho}0
0 0 0
0 0 0
0 0 0
⌹3 3⍴1 2 3 4
¯0.1944444444 0.2777777778 0.02777777778
0.05555555556 ¯0.2222222222 0.2777777778
0.3611111111 0.05555555556 ¯0.1944444444
⌹3 3⍴1 2 3 4<pn>x</pn>
¯7<pn>r</pn>36 5<pn>r</pn>18 1<pn>r</pn>36
1<pn>r</pn>18 ¯2<pn>r</pn>9 5<pn>r</pn>18
13<pn>r</pn>36 1<pn>r</pn>18 ¯7<pn>r</pn>36
</pre></apll>

<table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td>
<table border="0" cellpadding="5" cellspacing="0" summary="">
<tr>
<td valign="top"><apll>Z←L⌹R</apll></td>
<td></td>
<td></td>
<td>returns the quotient of the left and right arguments. This quotient can be interpreted in various ways, such as the least squares solution of the system of linear equations determined by arguments.</td>
</tr>
</table>
</td>
</tr>
<tr>
<td><apll>L</apll> is a numeric scalar, vector or matrix; otherwise signal a <apll>RANK ERROR</apll>.</td>
</tr>
<tr>
<td><apll>R</apll> is a numeric scalar, vector or matrix; otherwise signal a <apll>RANK ERROR</apll>.</td>
</tr>
<tr>
<td>If either <apll>L</apll> or <apll>R</apll> is a scalar or vector, it is coerced to a matrix by <apll>(L R)←⍪{each}L R</apll>. After this coercion, if the two matrices have a different number of rows, signal a <apll>LENGTH ERROR</apll>.</td>
</tr>
<tr>
<td><apll>Z</apll> is a numeric array. Before the above coercion of <apll>L</apll> and <apll>R</apll>, the rank of <apll>Z</apll> is <apll>¯2+2⌈(⍴⍴L)+⍴⍴R</apll>, and the shape is <apll>(1↓⍴R),1↓⍴L</apll>.</td>
</tr>
</table>
 
This feature implements matrix division on '''Boolean''', '''integer''' and '''floating point''' arguments using [http://www.gnu.org/software/gsl/manual/html_node/Singular-Value-Decomposition.html Singular Value Decomposition]. In particular, this means that any two numeric arrays meeting the rank and shape requirements above are divisible.

As noted above, Matrix Division on '''Rational''', '''VFP''', or '''Ball''' arguments uses a different algorithm and has slightly more restrictive conformability requirements.
<ul>
<li>for a '''square''' (<apll>=/⍴R</apll>) right argument that it be non-singular, and</li>
<li>for an '''overdetermined''' (<apll>>/⍴R</apll>) or '''underdetermined''' (<apll></⍴R</apll>) right argument that the symmetric matrix <apll>(⍉R)+.×R</apll> be non-singular.</li>
</ul>

Overdetermined matrices are evaluated equivalently to the expression <apll>(⌹(⍉R)+.×R)+.×(⍉R)+.×L</apll>.
Underdetermined matrices are evaluated equivalently to the expression <apll>(⍉R)+.×⌹R+.×(⍉R)+.×L</apll>.

For example,

<apll><pre>
a←3 3⍴0
a⌹a
0 0 0
0 0 0
0 0 0
1 2 3⌹3 3⍴1 2 3 4
0.4444444444 0.4444444444 ¯0.1111111111
1 2 3⌹3 3⍴1 2 3 4<pn>x</pn>
4<pn>r</pn>9 4<pn>r</pn>9 ¯1<pn>r</pn>9</pre></apll>

<hr width=35%> 

<big>For several more everyday problem-solving examples using Matrix Inverse see also '''[[Symbol_Domino|Domino Symbol ⌹]]'''.</big>

 <hr width=35%>

{{Article footer|2|Matrix}}

Matrix Inverse/Divide

2019-10-16T16:25:25Z

Paul Robinson: add explanation

Variant

2019-10-16T16:15:35Z

Paul Robinson: add cat

'''Caution:''' Be careful not to confuse this symbol, which is <apll>⍠</apll>, with <apll>⌹</apll> which is [[Matrix Inverse/Divide]].
<hr /><table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td>
<table border="0" cellpadding="5" cellspacing="0" summary="">
<tr>
<td valign="top"><apll>Z←f⍠B R</apll>    or    <apll>Z←L f⍠B R</apll></td>
<td></td>
<td></td>
<td>evaluates <apll>f R</apll> or <apll>L f R</apll> in the context described by <apll>B</apll>.</td>
</tr>
</table>
</td>
</tr>
<tr>
<td><apll>L</apll> and <apll>R</apll> are arbitrary arrays conformable with <apll>f</apll>, and <apll>B</apll> is a simple scalar, simple or heterogeneous vector, or nested vector.</td>
</tr>
<tr>
<td><apll>f</apll> is an arbitrary function.</td>
</tr>
</table>

==Introduction==

The dyadic Variant operator creates a version of the function <apll>f</apll> with a set of properties bound and localized to it as specified by the array right operand. For example, <apll>⍳⍠0</apll> is a version of <apll>⍳</apll> that executes in origin-0 independent of the current value of <apll>⎕IO</apll>.

The array right operand to the operator may take several different forms depending upon the function left operand. In the general case, for any kind of function left operand, the right operand may specify a single property in the form of <apll>Key Val</apll>, or multiple properties in the form of <apll>(Key1 Val1) (Key2 Val2)</apll>…, or if the left operand is a primitive function, a shorthand notation may be used as in <apll>Val</apll> or <apll>Val1 Val2</apll> ….

In the general case, the keys specify a property such as Index Origin as <apll>'IO'</apll> or Comparison Tolerance as <apll>'CT'</apll>, and the value part specifies a value appropriate to the property specified in the matching key. At the moment, the keys that may be used are <apll>'CT'</apll>, <apll>'DT'</apll>, <apll>'FPC'</apll>, <apll>'IO'</apll>, <apll>'LR'</apll>, <apll>'PP'</apll>, and <apll>'RL'</apll> which stand for the corresponding system variable. Note that for the Variants of <apll>L×R</apll> and <apll>⌹R</apll> and the Subsequence variants such as <apll>L⍳⍠'a' R</apll> there are no corresponding system variables as yet.

For example:

<apll><pre>
1 2 (3+1e¯9)  3⍳⍠(('IO' 0) ('CT' 1e¯10)) 3
3
1 2 (3+1e¯10) 3⍳⍠(('IO' 0) ('CT' 1e¯10)) 3
2
⍳⍠('IO' 0) 3
0 1 2
⍳⍠('IO' 1) 3
1 2 3
⍳⍠('IO' 0) ⍠('IO' 1) 3
0 1 2
⍳⍠('IO' 1) ⍠('IO' 0) 3
1 2 3</pre></apll>

Note that in the last two examples, the lefthand (innermost) value of <apll>⎕IO</apll> takes precedence.

==Shorthand Notation==

If the left operand is a primitive or derived function, the following shorthand notation may be used:

<table border="1" cellpadding="5" cellspacing="0" rules="all" summary="">
<tr>
<th width="20%">Function or Principal Operator</th>
<th width="5%">Right Arg Type</th>
<th width="75%">Meaning</th>
</tr>

<tr>
<td><apll>⍳R</apll></td>
<td>N</td>
<td><apll>⎕IO←</apll>N</td>
</tr>

<tr>
<td rowspan="8"><apll>L⍳R</apll></td>
<td>N</td>
<td><apll>⎕IO←</apll>N</td>
</tr>

<tr>
<td>N1 N2</td>
<td><apll>⎕IO←</apll>N1 and <apll>⎕CT←</apll>N2</td>
</tr>

<tr>
<td>C</td>
<td>[[#Subsequences|Subsequence]] C (<apll>'a'</apll> for Ascending, <apll>'d'</apll> for Descending)</td>
</tr>

<tr>
<td>N C</td>
<td><apll>⎕IO←</apll>N and [[#Subsequences|Subsequence]] C (<apll>'a'</apll> for Ascending, <apll>'d'</apll> for Descending)</td>
</tr>

<tr>
<td>C N</td>
<td><apll>⎕IO←</apll>N and [[#Subsequences|Subsequence]] C (<apll>'a'</apll> for Ascending, <apll>'d'</apll> for Descending)</td>
</tr>

<tr>
<td>N1 N2 C</td>
<td><apll>⎕IO←</apll>N1, <apll>⎕CT←</apll>N2, and [[#Subsequences|Subsequence]] C (<apll>'a'</apll> for Ascending, <apll>'d'</apll> for Descending)</td>
</tr>

<tr>
<td>N1 C N2</td>
<td><apll>⎕IO←</apll>N1, <apll>⎕CT←</apll>N2, and [[#Subsequences|Subsequence]] C (<apll>'a'</apll> for Ascending, <apll>'d'</apll> for Descending)</td>
</tr>

<tr>
<td>C N1 N2</td>
<td><apll>⎕IO←</apll>N1, <apll>⎕CT←</apll>N2, and [[#Subsequences|Subsequence]] C (<apll>'a'</apll> for Ascending, <apll>'d'</apll> for Descending)</td>
</tr>

<tr>
<td><apll>L⌷R</apll>, <apll>L⍉R</apll>, <apll>⍋R</apll>, <apll>L⍋R</apll>, <apll>⍒R</apll>, <apll>L⍒R</apll>, <apll>L⊃R</apll>, <apll>⍸R</apll>, <apll>LπR</apll>, <apll>a‼R</apll></td>
<td>N</td>
<td><apll>⎕IO←</apll>N</td>
</tr>

<tr>
<td><apll>⍕R</apll> and <apll>L⍕R</apll></td>
<td>N</td>
<td><apll>⎕PP←</apll>N</td>
</tr>

<tr>
<td><apll><apll>L<R</apll>, <apll>L≤R</apll>, <apll>L=R</apll>, <apll>L≠R</apll>, <apll>L≥R</apll>, <apll>L>R</apll>, 
<apll>L∊R</apll>, <apll>L≡R</apll>, <apll>L≢R</apll>, <apll>L∪R</apll>, <apll>L∩R</apll>, 
<apll>L⊆R</apll>, <apll>L⊇R</apll>, <apll>L§R</apll>, <apll>L~R</apll>, <apll>L⍷R</apll>, 
<apll>⌊R</apll>, <apll>⌈R</apll>, <apll>∪R</apll></td>
<td>N</td>
<td><apll>⎕CT←</apll>N</td>
</tr>

<tr>
<td rowspan="4"><apll>L|R</apll>, <apll>f⌻R</apll>, <apll>L f⌻R</apll>, <apll>∘⌻R</apll></td>
<td>N</td>
<td><apll>⎕CT←</apll>N</td>
</tr>

<tr>
<td>C</td>
<td><apll>⎕LR←</apll>C</td>
</tr>

<tr>
<td>N C
<td><apll>⎕CT←</apll>N and <apll>⎕LR←</apll>C</td>
</tr>

<tr>
<td>C N
<td><apll>⎕CT←</apll>N and <apll>⎕LR←</apll>C</td>
</tr>

<tr>
<td rowspan="8"><apll>?R</apll> and <apll>L?R</apll></td>
<td>N</td>
<td><apll>⎕IO←</apll>N</td>
</tr>

<tr>
<td>N1 N2</td>
<td><apll>⎕IO←</apll>N1 and <apll>⎕RL←</apll>N2</td>
</tr>

<tr>
<td>C</td>
<td><apll>⎕DT←</apll>C</td>
</tr>

<tr>
<td>N C
<td><apll>⎕IO←</apll>N and <apll>⎕DT←</apll>C</td>
</tr>

<tr>
<td>C N
<td><apll>⎕IO←</apll>N and <apll>⎕DT←</apll>C</td>
</tr>

<tr>
<td>N1 N2 C</td>
<td><apll>⎕IO←</apll>N1, <apll>⎕RL←</apll>N2, and <apll>⎕DT←</apll>C</td>
</tr>

<tr>
<td>N1 C N2</td>
<td><apll>⎕IO←</apll>N1, <apll>⎕RL←</apll>N2, and <apll>⎕DT←</apll>C</td>
</tr>

<tr>
<td>C N1 N2</td>
<td><apll>⎕IO←</apll>N1, <apll>⎕RL←</apll>N2, and <apll>⎕DT←</apll>C</td>
</tr>

<tr>
<td rowspan="2"><apll>!R</apll> ([https://en.wikipedia.org/wiki/Pochhammer_k-symbol Pochhammer k-symbol])</td>
<td>N</td>
<td>[[#Rising_and_Falling_Factorials|Rising (N > 0) and Falling (N < 0) factorial]] of length <apll>|</apll>N, stepping by <apll>1</apll> in the direction of N</td>
</tr>

<tr>
<td>N1 N2</td>
<td>[[#Rising_and_Falling_Factorials|Rising (N1 > 0) and Falling (N1 < 0) factorial]] of length <apll>|</apll>N1, stepping by <apll>|</apll>N2 in the direction of N1</td>
</tr>

<tr>
<td><apll>⍎R</apll></td>
<td>N</td>
<td><apll>⎕FPC←</apll>N</td>
</tr>

<tr>
<td><apll>L÷R</apll>, <apll>L∨R</apll>, <apll>L∧R</apll>, <apll>L○R</apll>, <apll>L⊤R</apll></td>
<td>C</td>
<td><apll>⎕LR←</apll>C</td>
</tr>

<tr>
<td><apll>L×R</apll></td>
<td>C</td>
<td>Except for Dot Product, these variants are non-trivial only when multiplying Non-commutative numbers. The following definitions on scalar <apll>L</apll> and <apll>R</apll> extend to higher rank arrays in the usual way. 
<table border="1" cellpadding="10" cellspacing="0" rules="all" summary="">
<tr>
<th>C</th>
<th>Name</th>
<th>Quaternion/Octonion — Non-commutative</th>
<th>Real/Complex — Commutative</th>
</tr>
<tr>
<td><apll>'i'</apll></td>
<td>Interior product</td>
<td><apll>((L×R)+R×L)÷2</apll></td>
<td><apll>L×R</apll></td>
</tr>
<tr>
<td><apll>'e'</apll></td>
<td>Exterior product</td>
<td><apll>((L×R)-R×L)÷2</apll></td>
<td><apll>0</apll></td>
</tr>
<tr>
<td><apll>'x'</apll></td>
<td>Cross product</td>
<td><apll>¯9○<(∘⌻¯9○L)+.×>¯9○R</apll>   Quaternions only where <apll>¯9○R</apll> returns <apll>(R-+R)÷2</apll>, i.e. as a pure imaginary number</td>
<td><apll>0</apll></td>
</tr>
<tr>
<td><apll>'d'</apll></td>
<td>Dot product</td>
<td><apll>(>L)+.×>R</apll></td>
<td>(same)</td>
</tr>
<tr>
<td><apll>'c'</apll></td>
<td>Conjugation product</td>
<td><apll>L×R÷L</apll></td>
<td><apll>R</apll></td>
</tr>
</table>
</td>
</tr>

<tr>
<td><apll>⌹R</apll></td>
<td>N</td>
<td>where N may be <apll>1</apll>, <apll>2</apll>, <apll>3</apll>, or <apll>4</apll>. <apll>R</apll> must be a square simple Real numeric matrix. If N is <apll>1</apll>, the result is a Complex floating point vector of the [https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors Eigenvalues] of <apll>R</apll>. If N is 2, the result is a Complex floating point matrix of the [https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors Eigenvectors] of <apll>R</apll>, one per column. If N is <apll>3</apll>, the result is a two-element nested vector with a Complex vector of the Eigenvalues in the first element and a Complex matrix of the Eigenvectors in the second. If N is <apll>4</apll>, the result is a three-element nested vector with a Complex vector of the Eigenvalues in the first element, a Complex matrix of the Eigenvectors in the second, and a Real matrix of the Schur vectors in the third. For more details see [[#Eigenvalues_and_Eigenvectors|Eigenvalues and Eigenvectors]].</td>
</tr>

<tr>
<td><apll>f.g/0⍴⊂R</apll></td>
<td>C</td>
<td><apll>⎕LR←</apll>C — this value is used only when the identity function for inner product is called so as to distinguish the Left identity element from the Right. For example, with <apll>R←3 4⍴⍳12</apll>, the expression <apll>⊃+.×⍠'l'/0⍴⊂R</apll> produces the Left identity element (which is a <apll>3</apll> by <apll>3</apll> identity matix) and <apll>⊃+.×⍠'r'/0⍴⊂R</apll> produces the Right identity element (which is a <apll>4</apll> by <apll>4</apll> identity matrix). The actual values in the result are dependent on the functions f and g.</td>
</tr>
</table>
 

==Subsequences==

===Ascending===

An Ascending subsequence of one vector in another (<apll>L⍳⍠'a' R</apll>) is a set of indices of <apll>L</apll> (barring items Not Found) such that <apll>R≡L[L⍳⍠'a' R]</apll> and <apll>∧/2</L⍳⍠'a' R</apll>, that is the indices are monotonically increasing. This primitive is written such that it returns the smallest values that satisfy the above conditions. All datatypes are valid for the left and right arguments; the result is always an integer vector of the same length as <apll>R</apll>.

For example:

<apll><pre>
L←2 7 1 5 7 1 2 1 7 1
R←5 2 7 1
L⍳⍠'a' R
4 7 9 10
L[L⍳⍠'a' R]
5 2 7 1
</pre></apll>

If an element in <apll>R</apll> is Not Found, the corresponding value in the result is <apll>⎕IO+⍴L</apll>. Moreover, if an element in <apll>R</apll> is Not Found, then all following elements in <apll>R</apll> are also Not Found.

Continuing the above example:

<apll><pre>
LL←L,3
RR←R,9 3
LL⍳⍠'a' RR
4 7 9 10 12 12
(LL,'?')[LL⍳⍠'a' RR]
5 2 7 1 ??
</pre></apll>

===Descending===

A Descending subsequence of one vector in another (<apll>L⍳⍠'d' R</apll>) is a set of indices of <apll>L</apll> (barring items Not Found) such that <apll>R≡L[L⍳⍠'d' R]</apll> and <apll>∧/2>/L⍳⍠'d' R</apll>, that is the indices are monotonically decreasing. This primitive is written such that it returns the largest values that satisfy the above conditions. All datatypes are valid for the left and right arguments; the result is always an integer vector of the same length as <apll>R</apll>.

For example:

<apll><pre>
L←1 2 5 7 2 1 5 7 1 2 5 5 1 2 7
R←5 2 7 1
L⍳⍠'d' R
12 10 8 6
L[L⍳⍠'d' R]
5 2 7 1
</pre></apll>

If an element in <apll>R</apll> is Not Found, the corresponding value in the result is <apll>⎕IO-1</apll>. Moreover, if an element in <apll>R</apll> is Not Found, then all following elements in <apll>R</apll> are also Not Found.

Continuing the above example:

<apll><pre>
LL←3,L
RR←R,9 3
LL⍳⍠'d' RR
13 11 9 7 0 0
('?',LL)[1+LL⍳⍠'d' RR]
5 2 7 1 ??
</pre></apll>

===Combining Variants===

Dyadic Iota allows several other Variants such as setting the Index Origin and Comparison Tolerance. They may be combined into one right operand, for example, any of the following expressions

<apll> L⍳⍠(0 1E¯10 'd') R</apll>   or 
<apll> L⍳⍠(0 'd' 1E¯10) R</apll>   or 
<apll> L⍳⍠('d' 0 1E¯10) R</apll> 

may be used to find a Descending Subsequence in origin-0 using a Comparison Tolerance of <apll>1E¯10</apll>.

The order of the two numeric values is important: if there is only one number in the right operand, it is applied to the Index Origin; if there are two numbers, the first is applied to the Index Origin and the second to the Comparison Tolerance. The character value may appear anywhere in the right operand — however if a second character-valued Variant were defined for Dyadic Iota, then the two character values would also be order-dependent.

===Identities For Subsequences===

The following identities hold in either Index Origin even if there are Not Found values in the result:

<apll> (L⍳⍠'a' R)≡(1 ¯1[1]+⍴L)-(⌽L)⍳⍠'d' R</apll> 
<apll> (L⍳⍠'d' R)≡(1 ¯1[1]+⍴L)-(⌽L)⍳⍠'a' R</apll>

==Rising and Falling Factorials==

A falling factorial is like a normal factorial except that it subtracts the step value (by default <apll>1</apll> unless overridden) from the original number for a fixed # of iterations. That is, <apll>!6</apll> successively decrements <apll>6</apll> by <apll>1</apll> and multiplies the numbers <apll>6 5 4 3 2 1</apll> to get <apll>720</apll>. A falling factorial starting with <apll>6</apll> of length (say) <apll>3</apll> multiplies <apll>6 5 4</apll> to get <apll>120</apll>.


A rising factorial is like a falling factorial except it adds the step value (by default <apll>1</apll> unless overridden) instead of subtracting it. A rising factorial starting with <apll>6</apll> of length (say) <apll>3</apll> multiplies <apll>6 7 8</apll> to get <apll>336</apll>.


Here are some examples of the falling factorial

<apll><pre>
!6
720
(!⍠¯6)6 ⍝ ×/6 5 4 3 2 1
720
(!⍠¯5)6 ⍝ ×/6 5 4 3 2
720
(!⍠¯4)6 ⍝ ×/6 5 4 3
360
(!⍠¯3)6 ⍝ ×/6 5 4
120
(!⍠¯2)6 ⍝ ×/6 5
30
(!⍠¯1)6 ⍝ ×/6
6
(!⍠¯0)6 ⍝ ×/⍬
1
</pre></apll>

and now falling by <apll>2</apll>

<apll><pre>
(!⍠(¯6 2))6 ⍝ ×/6 4 2 0 ¯2 ¯4
0
(!⍠(¯5 2))6 ⍝ ×/6 4 2 0 ¯2
0
(!⍠(¯4 2))6 ⍝ ×/6 4 2 0
0
(!⍠(¯3 2))6 ⍝ ×/6 4 2
48
(!⍠(¯2 2))6 ⍝ ×/6 4
24
(!⍠(¯1 2))6 ⍝ ×/6
6
(!⍠(¯0 2))6 ⍝ ×/⍬
1
</pre></apll>

and here are some examples of the rising factorial

<apll><pre>
(!⍠6)6 ⍝ ×/6 7 8 9 10 11
332640
(!⍠5)6 ⍝ ×/6 7 8 9 10
30240
(!⍠4)6 ⍝ ×/6 7 8 9
3024
(!⍠3)6 ⍝ ×/6 7 8
336
(!⍠2)6 ⍝ ×/6 7
42
(!⍠1)6 ⍝ ×/6
6
(!⍠0)6 ⍝ ×/⍬
1
</pre></apll>

and now rising by <apll>2</apll>

<apll><pre>
(!⍠(6 2))6 ⍝ ×/6 8 10 12 14 16
1290240
(!⍠(5 2))6 ⍝ ×/6 8 10 12 14
80640
(!⍠(4 2))6 ⍝ ×/6 8 10 12
5760
(!⍠(3 2))6 ⍝ ×/6 8 10
480
(!⍠(2 2))6 ⍝ ×/6 8
48
(!⍠(1 2))6 ⍝ ×/6
6
(!⍠(0 2))6 ⍝ ×/⍬
1
</pre></apll>

===Identities For Rising and Falling Factorials===

<table border="1" cellpadding="5" cellspacing="5" rules="none" summary="">
<tr>
<td><apll>(!⍠N)R</apll></td>
<td><apll>  ←→  </apll></td>
<td><apll>(!⍠(N 1))R</apll></td>
</tr>

<tr>
<td><apll>(!⍠(N 0))R</apll></td>
<td><apll>  ←→  </apll></td>
<td><apll>R*N</apll></td>
</tr>

<tr>
<td><apll>(!⍠(N1,N2))R</apll></td>
<td><apll>  ←→  </apll></td>
<td><apll>(!⍠(N1,|N2))R</apll></td>
<td>  (the sign of <apll>N2</apll> is ignored)</td>
</tr>
</table>

==Eigenvalues and Eigenvectors==

These [https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors concepts] from Linear Algebra and Matrix Theory define the characteristic values and vectors of the linear transformation represented by a matrix. Every square simple Real numeric matrix has Eigenvalues and Eigenvectors. To calculate these objects, use the Variant operator with a left operand of the Domino function and a right operand of an integer scalar according to the following table:

{| border="1" cellpadding="5" cellspacing="5" rules="all" summary="" style=""border:1px solid black;"
|<apll>Z←(⌹⍠1) R</apll>||<apll>Z</apll> is a Complex floating point vector of the Eigenvalues of <apll>R</apll>
|-
|<apll>Z←(⌹⍠2) R</apll>||<apll>Z</apll> is a Complex floating point matrix of the Eigenvectors of <apll>R</apll>, one per column
|-
|<apll>Z←(⌹⍠3) R</apll>||<apll>Z</apll> is a two-element nested vector with a Complex floating point vector of the Eigenvalues in the first element and a Complex floating point matrix of the Eigenvectors in the second
|-
|<apll>Z←(⌹⍠4) R</apll>||<apll>Z</apll> is a three-element nested vector with a Complex floating point vector of the Eigenvalues in the first element, a Complex floating point matrix of the Eigenvectors in the second, and a Real matrix of the Schur vectors in the third
|}

For example, Eigenvalues and Eigenvectors can be used to calculate the factorial of a matrix:

<apll><pre>
&ensp; M←2 2⍴1 3 2 1
&ensp; M
&ensp; 1 3
&ensp; 2 1
&ensp; MatFact←{(Eval Evec)←(⌹⍠3) ⍵
➥⋄ Diag←∘⌻!Eval ⍝ Factorial of Eigenvalues on diagonal
➥⋄ Evec+.×Diag+.×⌹Evec}
&ensp; MatFact M
&ensp; 3.6274 8.8423
&ensp; 5.8949 3.6274
</pre></apll>

Note that if we delete the Shriek function in <apll>MatFact</apll>, the result is the original matrix argument.

In turn, the function <apll>MatFact</apll> can be used to calculate the Factorial of a HyperComplex number:

<apll><pre>
&ensp; HyperFact←{M←∘⌻⍵ ⍝ Matrix representation of a HyperComplex number
➥⋄ ⎕IO←1 ⋄ <9○1⌷[2] MatFact M ⍝ Factorial ...
➥}
&ensp; HyperFact 1i2
&ensp; 0.11229J0.32361
&ensp; !1i2
&ensp; 0.11229J0.32361
</pre></apll>

where the latter expression uses the Gnu Scientific Library Complex number routines to calculate the Factorial of a Complex number.

In a similar manner, using the appropriate <apll>4×4</apll> matrix representation of a Quaternion, its Factorial can be calculated which is the algorithm used in the implementation:

<apll><pre>
&ensp; HyperFact <⍳4
&ensp; 0.0060975i¯0.0010787j¯0.001618k¯0.0021573
&ensp; !<⍳4
&ensp; 0.0060975i¯0.0010787j¯0.001618k¯0.0021573
</pre></apll>

{{Article footer|9|Variant}}
[[Category:Operators]]

⍠

2019-10-16T16:09:06Z

Paul Robinson: r to article

#REDIRECT [[Variant]]

Operators

2019-10-16T15:39:08Z

Paul Robinson: add cat

Operators are symbols used to perform an action based on the operands (functions, variables, or jots) to its left (monadic operator) or left and right (dyadic operator), along with the zero, one, or two arguments to the derived function from the operator. That is, the derived function may be niladic (no arguments), monadic (right argument only), or dyadic (left and right arguments). For example, <apll>⍨</apll> is a monadic operator (a single operand on its left, e.g. <apll>f⍨</apll>), and the derived function from this operator is ambivalent (that is, may be called with a right argument only as in <apll>f⍨ R</apll> or both left and right arguments, as in <apll>L f⍨ R</apll>).

The list of monadic operators is as follows:

{| border="1" cellpadding="5" cellspacing="0"
|-
| <apll>/</apll> || [[Reduction]] || <apll>f/ R</apll> || <apll>L f/ R</apll>
|-
| <apll>\</apll> || [[Scan]] || <apll>f\ R</apll> || <apll>L f\ R</apll>
|-
| <apll>¨</apll> || [[Each]] || <apll>f¨ R</apll> || <apll>L f¨ R</apll>
|-
| <apll>⍨</apll> || [[Commute-Duplicate|Duplicate/Commute]] || <apll>f⍨ R</apll> || <apll>L f⍨ R</apll>
|-
| <apll>⍦</apll> || [[Multisets]] || <apll>f⍦ R</apll> || <apll>L f⍦ R</apll>
|-
| <apll>‼</apll> || [[Combinatorial]] || <apll>v‼ R</apll> ||
|-
| <apll>⊙</apll> || [[Null]] || <apll>f⊙ R</apll> || <apll>L f⊙ R</apll>
|}

The list of dyadic operators is as follows:

{| border="1" cellpadding="5" cellspacing="0"
|-
| <apll>⍤</apll> || [[Rank]] || <apll>f⍤w R</apll> || <apll>L f⍤w R</apll>
|-
| <apll>⍡</apll> || [[Convolution]] || || <apll>L f⍡g R</apll>
|-
| <apll>⍥</apll> || [[Composition]] || || <apll>L f⍥g R</apll>
|-
| <apll>.</apll> || [[Determinant_Operator|Determinant Inner Product Outer product]] || <apll>f.g R</apll> || <apll>L f.g R</apll> <apll>L ∘.g R</apll>
|-
| <apll>∘</apll> || [[Compose]] || <apll>f∘g R</apll> <apll>f∘w R</apll> <apll>v∘g R</apll> || <apll>L f∘g R</apll>
|-
| <apll>⍠</apll> || [[Variant]] || <apll>f⍠w R</apll> || <apll>L f⍠w R</apll>
|}

Where <apll>f</apll> and <apll>g</apll> represent functions and <apll>v</apll> and <apll>w</apll> represent variables.

{{Article footer|0|NO}}

{{stub}}
[[Category:Examples]][[Category:Definitions]]

Introduction to APL

2019-10-16T15:32:04Z

Paul Robinson: make minor changes to correct errors

Welcome to the wonderful world of APL. Whether you've never done programming before or you're a journeyman programmer, APL is going to be something new to you. APL works like no other programming language. First, if you've done any programming, you "know" that when you have an assignment or something like a piece of code is executed, it's "always" done left to right and mathematical formulas are always evaluated left to right according to precedence, so that exponentiation is done first, then multiplication and division, then addition and subtraction. Well, APL is going to blow you away because ''everything you know is wrong''.

First, APL is "backwards" to what you know. APL operates from ''right to left''. All other programming languages operate from left to right. When it comes to computing mathematical formulas, APL has no precedence; unless you put something in parenthesis, all mathematical computations are done strictly right to left to produce the result.

Also, APL uses a specialized set of symbols, and before we had graphical systems, it even had its own specialized keyboard. Many of the actions you have to write a program in other languages can be done in one character in APL. While your typical programming language would show 3 times 4 as '''3*4''', APL has a multiply symbol, so it is written as '''3{times}4''', and to create one half or '''1/2''' in most languages, in APL you would enter '''1{divide}2''' .

So, for example, if you have the following mathematical expression
: 4*5-10 (in normal programming languages), or in APL: 4 {times} 5 - 10
Your typical programming language would compute it as 4{times}5 which is (20), then 20 - 10, resulting in 10. APL will compute it as 5-10 (-5) * 4, or -20. You can adjust this by placing arguments within parenthesis. If your expression was written as
: (4 {times} 5) - 10
It would produce the same answer no matter what programming language you use.

Where APL shines is its ability to handle arrays as easily as most programs handle single values. For example, the '''plus reduce''' operator is used to sum a list of numbers, so in a typical programming language like C or C++ you'd have
: K == 5 + 6 + 8 + 9 + 12 +14
In APL, you'd do the same thing with
: K {:=} +/5 6 8 9 12 14
Now, that by itself isn't very exciting. But what if you had an array X of 1000 numbers. In C you'd have to do something like 
<code>
     k == 0;
     for (i=1;i++;i<1001) {
          k += X[i];
     }</code>

You'd do the same thing in APL with
: k {:=} +/ X
APL will take all of the entries in the array X and sum them, in one instruction. You don't even have to know how many entries are in the array X; APL will handle it for you.

To be able to program in APL you'll have to learn what all of the operators do. Links to pages describing APL/APL2 symbols and what they do, just below:
* [[Operators]]
* [[Language_Features]]

[[Category:Examples]]

Introduction to APL

2019-10-16T15:22:30Z

Paul Robinson: add cat

Welcome to the wonderful world of APL. Whether you've never done programming before or you're a journeyman programmer, APL is going to be something new to you. APL works like no other programming language. First, if you've done any programming, you "know" that when you have an assignment or something like a piece of code is executed, it's "always" done right to left and mathematical formulas are always evaluated right to left according to precedence, so that exponentiation is done first, then multiplication and division, then addition and subtraction. Well, APL is going to blow you away because ''everything you know is wrong''.

First, APL is "backwards" to what you know. APL operates from ''right to left''. All other programming languages operate from left to right. When it comes to computing mathematical formulas, APL has no precedence; unless you put something in parenthesis, all mathematical computations are done strictly right to left to produce the result.

Also, APL uses a specialized set of symbols, and before we had graphical systems, it even had its own specialized keyboard. Many of the actions you have to write a program in other languages can be done in one character in APL. While your typical programming language would show 3 times 4 as '''3*4''', APL has a multiply symbol, so it is written as '''3{times}4''', and to create one half or '''1/2''' in most languages, in APL you would enter '''1{divide}2''' .

So, for example, if you have the following mathematical expression
: 4*5-10 (in normal programming languages), or in APL: 4 {times} 5 - 10
Your typical programming language would compute it as 4{times}5 which is (20), then 20 - 10, resulting in 10. APL will compute it as 5-10 (-5) * 4, or -20. You can adjust this by placing arguments within parenthesis. If your expression was written as
: (4 {times} 5) - 10
It would produce the same answer no matter what programming language you use.

Where APL shines is its ability to handle arrays as easily as most programs handle single values. For example, the '''plus reduce''' operator is used to sum a list of numbers, so in a typical programming language like C or C++ you'd have
: K == 5 + 6 + 8 + 9 + 12 +14
In APL, you'd do the same thing with
: K {:=} +/5 6 8 9 12 14
Now, that by itself isn't very exciting. But what if you had an array X of 1000 numbers. In C you'd have to do something like 
<code>
     k == 0;
     for (i=1;i++;i<1001) {
          k += X[i];
     }</code>

You'd do the same thing in APL with
: k {:=} +/ X
APL will take all of the entries in the array X and sum them, in one instruction. You don't even have to know how many entries are in the array X; APL will handle it for you.

To be able to program in APL you'll have to learn what all of the operators do. Links to pages describing APL/APL2 symbols and what they do, just below:
* [[Operators]]
* [[Language_Features]]

[[Category:Examples]]

System Variable FPC

2019-10-13T23:03:19Z

Paul Robinson:

<h1><aplxx>⎕FPC</aplxx> - Floating Point Control</h1>
{{BoxStart|<apll>Z←⎕FPC</apll>
|returns the current value of the Floating Point Control precision.}}
{{BoxEnd|<apll>Z</apll> is an integer scalar that represents the current value of the number of bits of precision used for [[Rational and VFP Numbers|Multiple-Precision Floating Point numbers]].}}
 

{| border="1" cellpadding="5" cellspacing="0" rules="none" summary=""
|-
||<apll>⎕FPC←R</apll>
||sets the value of the Floating Point Control precision to <apll>R</apll>.
|-
||<apll>⎕FPC←⍬</apll>
||sets the value of the Floating Point Control precision to its system default state.
|}
 


The approximate number of digits of precision for a given value of <apll>⎕FPC</apll> is about <apll>10⍟2*⎕FPC</apll>. The value of <apll>⎕FPC</apll> for a given required precision is about <apll>⌈2⍟10*digits</apll>.


The minimum value for <apll>⎕FPC</apll> is <apll>1</apll>; the maximum value is the integer <apll>1073741695 ←→ ¯129+2*30 ←→ 16<_b/>3FFFFF7F</apll>.

The system default value is <apll>128</apll>.

For example:

<apll><pre>
&ensp;&ensp; ⎕PP←240
&ensp;&ensp; ⎕FPC←64 ⋄ *1<_x/>
&ensp;&ensp;2.7182818284590452354
&ensp;&ensp; ⎕FPC←128 ⋄ *1<_x/>
&ensp;&ensp;2.71828182845904523536028747135266249776
&ensp;&ensp; ⎕FPC←256 ⋄ *1<_x/>
&ensp;&ensp;2.71828182845904523536028747135266249775724709369995957496696762
<_lc/> 772407663035355
&ensp;&ensp; ⎕FPC←512 ⋄ *1<_x/>
&ensp;&ensp;2.71828182845904523536028747135266249775724709369995957496696762
<_lc/> 7724076630353547594571382178525166427427466391932003059921
<_lc/> 8174135966290435729003342952605956
&ensp;&ensp; ⎕FPC←1024 ⋄ *1<_x/>
&ensp;&ensp;2.71828182845904523536028747135266249775724709369995957496696762
<_lc/> 7724076630353547594571382178525166427427466391932003059921
<_lc/> 8174135966290435729003342952605956307381323286279434907632
<_lc/> 3382988075319525101901157383418793070215408914993488416750
<_lc/> 924</pre></apll>

Whereas, according to Wolfram Alpha, the exact value to 230 digits is

<apll><pre>&ensp;&ensp;2.71828182845904523536028747135266249775724709369995957496696762
<_lc/> 7724076630353547594571382178525166427427466391932003059921
<_lc/> 8174135966290435729003342952605956307381323286279434907632
<_lc/> 3382988075319525101901157383418793070215408914993488...</pre></apll>

'''See Also: [[System_Variable_CT|Comparison Tolerance ⎕CT]]'''

{{System Variables}}
{{Article footer|0|NO}}
[[Category:System functions|FPC]] [[Category:Math functions|FPC]]

Rho

2019-10-13T23:00:04Z

Paul Robinson: t/c

__NOTOC__

{{Article header
|sym={rho}
|def=Shape or Reshape
|ks=ALT+r
|char=9076 or x2374
|kb=APLKB-Rho.png|kb2=}}

Note: This is ALT+r; ALT+SHIFT+R will generate the symbol [[Symbol Root|root]] ({root}).

Rho may be used as a [[monadic]] or [[dyadic]] operator, depending on the functionality desired. Used monadically with the argument to the right returns the '''shape''' of the argument. Used dyadically, the argument on the left is used to '''reshape''' the argument on the right.

==Shape - Monadic {rho}==
<big>Symbol '''{rho}''' when used '''monadically''' (no left argument) returns the '''shape of {rho}'s right argument''', i.e. the size or dimensions of a scalar, string, vector, array or matrix. Shape returns null for a scalar or a single character, it returns 0 for a null string, the length of a string of at least two characters, the number of elements of an array or vector, and the number of elements of a matrix.</big>
<apll><pre>
⍴ 1 2 3 4 5 6 ⍝ Rho in the case of vectors represents a Count(# elements) function
6
⍴'abcdefg' ⍝ Similarly with text strings(vector of chars), Rho represents a Count function
7
⍴ 1 ⍝ For a scalar right argument, Rho generates a null vector.

⍴⍴ 1 ⍝ The shape of the shape(⍴⍴) of a scalar (because the shape of a scalar is a null) - generates zero.
0
⍴ 'a' ⍝ Ditto for {numbers, integers, letters}, etc. - for scalar right arguments: Rho also generates a null vector.

⍴⍴ 'a'
0
⍴, 4.581 ⍝ Rho for a raveled(, or comma used) scalar(real num 4.581) - again correctly represents a Count(# elements) function
1

2 3⍴⍳6 ⍝ Dyadic call for demonstration purposes(see below for dyadic calls to {rho}): result = 2 rows and 3 cols matrix of integers(1..6)
1 2 3
4 5 6

⍴2 3⍴⍳6 ⍝ Monadic LEFTMOST shape {rho} yields: matrix has 2 rows and 3 cols; equivalent to ⍴(2 3⍴⍳6) which has parentheses added for clarity
2 3

⍴⍴(2 3⍴⍳6) ⍝ Monadic LEFTMOST shape-shape or {rho}{rho} generates the RANK of the 2 row, 3 col matrix which = 2 (matrix)
2
⍴⍴(⍳6) ⍝ Monadic leftmost {rho}{rho} generates the RANK of the vector = 1 (vector)
1
</pre></apll>

==Reshape - Dyadic {rho}==
<big>'''{rho}''''s Left Argument(L) output-reshapes {rho}'s Right Argument(R).</big>
<table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td>
<table border="0" cellpadding="5" cellspacing="0" summary="">
<tr>
<td valign="top"><apll>Z←L⍴R</apll></td>
<td></td>
<td></td>
<td>dyadic '''{rho}''' returns an array of shape <apll>L</apll> whose items are taken from <apll>R</apll> in row major order, repeated as necessary.</td>
</tr>
</table>
</td>
</tr>
<tr>
<td><apll>L</apll> is a scalar or vector of non-negative integers, and <apll>R</apll> is an arbitrary array.</td>
</tr>
<tr>
<td>If the right argument is empty, the result consists of <apll>×/⍴L</apll> copies of the fill item of <apll>R</apll>.
</tr>
</table>
 
For example, in origin <apll>1</apll> (where <apll>⎕IO=1</apll>)

<apll><pre>
2 3⍴⍳6
1 2 3
4 5 6
2 3⍴⍳0
0 0 0
0 0 0</pre></apll>

The idea for the latter enhancement was taken from Dyalog APL.

{{article footer|8|Rho}}
[[Category:Monadic operators]]
[[Category:Dyadic operators]]

Datatypes and Storage

2019-10-13T22:55:40Z

Paul Robinson: /* Type Demotion */

==Datatypes==

===Immediate Data===

If data meets specific criteria, it is stored in the Symbol Table instead of global memory. That is if it is a simple (Character, Boolean, Integer, Floating Point) scalar, it is represented in the Symbol Table as follows according to these structures which may be found in '''symtab.h''':

<pre>
// Symbol table flags
typedef struct tagSTFLAGS
{
UINT Imm:1, // 00000001: The data in .stData is Immediate simple numeric or character scalar
ImmType:5, // 0000003E: ... Immediate Boolean, Integer, Character, or Float (see IMM_TYPES)
Inuse:1, // 00000040: Inuse entry
Value:1, // 00000080: Entry has a value
ObjName:3, // 00000700: The data in .stData is NULL if .stNameType is NAMETYPE_UNK; value, address, or HGLOBAL otherwise
// (see OBJ_NAMES)
stNameType:4, // 00007800: The data in .stdata is value (if .Imm), address (if .FcnDir), or HGLOBAL (otherwise)
// (see NAME_TYPES)
SysVarValid:5, // 000F8000: Index to validation routine for System Vars (see SYS_VARS)
UsrDfn:1, // 00100000: User-defined function/operator/hyperator
DfnLabel:1, // 00200000: User-defined function/operator/hyperator label (valid only if .Value is set)
DfnSysLabel:1, // 00400000: User-defined function/operator/hyperator system label (valid only if .Value is set)
DfnAxis:1, // 00800000: User-defined function/operator/hyperator accepts axis value
FcnDir:1, // 01000000: Direct function/operator/hyperator (stNameFcn is valid)
StdSysName:1, // 02000000: Is a standard System Name
bIsAlpha:1, // 04000000: Is Alpha
bIsOmega:1, // 08000000: Is Omega
:4; // F0000000: Available bits
} STFLAGS, *LPSTFLAGS;

// N.B.: Whenever changing the above struct (STFLAGS),
// be sure to make a corresponding change to
// <astFlagNames> in <dispdbg.c>.

// .Inuse and .PrinHash are valid for all entries.
// .Inuse = 0 implies that all but .PrinHash are zero.
// .Imm implies one and only one of the IMMTYPE_***s
// .Imm = 1 implies that one and only one of aplBoolean, aplInteger, aplChar, or aplFloat is valid.
// .Imm = 0 implies that stGlbData is valid.
// .Value is valid for NAMETYPE_VAR only, however .stNameType EQ NAMETYPE_VAR
// should never be without a value.
// .UsrDfn is set when the function is user-defined.
// .FcnDir may be set for any function/operator/hyperator; it is a
// direct pointer to the code.
// htGlbName in HSHENTRY is set when .Imm and .FcnDir are clear.

// Immediate data or a handle to global data
typedef union tagSYMTAB_DATA
{
APLBOOL stBoolean; // 00: A number (Boolean)
APLINT stInteger; // 00: A number (Integer)
APLFLOAT stFloat; // 00: A floating point number
APLCHAR stChar; // 00: A character
HGLOBAL stGlbData; // 00: Handle of the entry's data
LPVOID stVoid; // 00: An abritrary ptr
LPPRIMFNS stNameFcn; // 00: Ptr to a named function
APLLONGEST stLongest; // 00: Longest datatype (so we can copy the entire data)
// 08: Length
} SYMTAB_DATA, *LPSYMTAB_DATA;

#define SYM_HEADER_SIGNATURE 'EMYS'

// Symbol table entry
typedef struct tagSYMENTRY
{
STFLAGS stFlags; // 00: Flags
SYMTAB_DATA stData; // 04: For immediates, the data value;
// for others, the HGLOBAL (8 bytes)
LPHSHENTRY stHshEntry; // 0C: Ptr to the matching HSHENTRY
struct tagSYMENTRY
*stPrvEntry, // 10: Ptr to previous (shadowed) STE (NULL = none)
*stSymLink; // 14: Ptr to next entry in linked list of
// similarly grouped entries (NULL = none)
UINT stSILevel; // 18: State Indicator Level for this STE
HEADER_SIGNATURE Sig; // 1C: STE header signature
// 20: Length
} SYMENTRY, *LPSYMENTRY;
</pre>

===Global Data===

Each global datatype type is stored in a global variable allocated by '''MyGlobalAlloc (GPTR | GHND, # Bytes)''' which returns a global memory handle (or '''NULL''' if an error occurs). The # Bytes is calculated by the function '''CalcArraySize (ARRAY_TYPE, APLNELM, APLRANK)'''. The ARRAY_TYPE enum is defined in '''datatype.h''' as follows:

<pre>// Array types -- used to identify array storage type in memory
typedef enum tagARRAY_TYPES
{
ARRAY_BOOL = 0 , // 00: Boolean
ARRAY_INT , // 01: Integer
ARRAY_FLOAT , // 02: Floating point
ARRAY_CHAR , // 03: Character
ARRAY_HETERO , // 04: Simple heterogeneous (mixed numeric and character scalars)
ARRAY_NESTED , // 05: Nested
ARRAY_LIST , // 06: List
ARRAY_APA , // 07: Arithmetic Progression Array
ARRAY_RAT , // 08: Multiprecision Rational Number
ARRAY_VFP , // 09: Variable-precision Float
ARRAY_HC2I , // 0A: Complex INT coefficients
ARRAY_HC2F , // 0B: ... FLT ...
ARRAY_HC2R , // 0C: ... RAT ...
ARRAY_HC2V , // 0D: ... VFP ...
ARRAY_HC4I , // 0E: Quaternion INT coefficients
ARRAY_HC4F , // 0F: ... FLT ...
ARRAY_HC4R , // 10: ... RAT ...
ARRAY_HC4V , // 11: ... VFP ...
ARRAY_HC8I , // 12: Octonion INT coefficients
ARRAY_HC8F , // 13: ... FLT ...
ARRAY_HC8R , // 14: ... RAT ...
ARRAY_HC8V , // 15: ... VFP ...

ARRAY_LENGTH , // 16: # elements in this enum
// *MUST* be the last non-error entry
// 17-1F: Available entries (5 bits)
ARRAY_INIT = ARRAY_LENGTH ,
ARRAY_ERROR = (APLSTYPE) -1 ,
ARRAY_NONCE = (APLSTYPE) -2 ,
ARRAY_REALONLY = (APLSTYPE) -3 ,

ARRAY_HC1I = ARRAY_INT , // To simplify common macros
ARRAY_HC1F = ARRAY_FLOAT , // ...
ARRAY_HC1R = ARRAY_RAT , // ...
ARRAY_HC1V = ARRAY_VFP , // ...
} ARRAY_TYPES;
</pre>

The '''APLNELM''' typedef is defined in '''types.h''' as follows (where '''ULONGLONG''' is defined as an unsigned 64-bit integer):

<pre>
typedef ULONGLONG APLNELM; // The type of the # elements in an array
</pre>

The '''APLRANK''' typedef is defined in '''types.h''' as follows:

<pre>
typedef ULONGLONG APLRANK; // The type of the rank element in an array
</pre>

===Headers===

Each global array is preceded in memory by a '''header''' and is defined in '''datatype.h''' as follows:

<pre>typedef struct tagHEADER_SIGNATURE
{
UINT nature; // 00: Array header signature (common to all types of arrays)
// 04: Length
} HEADER_SIGNATURE, *LPHEADER_SIGNATURE;

// Variable array header
#define VARARRAY_HEADER_SIGNATURE 'SRAV'

typedef struct tagVARARRAY_HEADER
{
HEADER_SIGNATURE Sig; // 00: Array header signature
UINT ArrType:5, // 04: 0000001F: The type of the array (see ARRAY_TYPES)
PermNdx:5, // 000003E0: Permanent array index (e.g., PERMNDX_ZILDE for {zilde})
SysVar:1, // 00000400: Izit for a Sysvar (***DEBUG*** only)?
PV0:1, // 00000800: Permutation Vector in origin-0
PV1:1, // 00001000: ... 1
bSelSpec:1, // 00002000: Select Specification array
All2s:1, // 00004000: Values are all 2s
#ifdef DEBUG
bMFOvar:1, // 00008000: Magic Function/Operator/Hyperator var -- do not display
:16; // FFFF0000: Available bits
#else
:17; // FFFF8000: Available bits
#endif
UINT RefCnt; // 08: Reference count
APLNELM NELM; // 0C: # elements in the array (8 bytes)
APLRANK Rank; // 14: The rank of the array (8 bytes)
// followed by the dimensions
// 1C: Length
} VARARRAY_HEADER, *LPVARARRAY_HEADER;
</pre>

===Characters===

There is only one character type ('''ARRAY_CHAR''') and is stored as 16-bit WORDs in UCS-2 format. This format is a subset of UTF-16LE in that it does not attempt to handle characters beyond the BMP (Basic Multilingual Plane), that is 16 bits.

===Numbers===

There are numerous numeric datatypes from Boolean to Octonions. All of the numeric datatypes in this section use the common header above. The data portion of the array immediately follows the header.

Booleans are stored in the usual one element per bit in Little-Endian format.

The rest of the numeric datatypes in this section can be described by the "outer product" of its dimension (1, 2, 4, 8) and its Basic Type (8-byte Integer, 8-byte Floating Point, '''__mpq_struct''' (24- or 32-byte) Multiple-precision Integer/Rational, and '''__mpfr_struct''' (32- or 40-byte) Multiple-precision Floating Point). Because a Multiple-precision number contains a pointer to its data, its byte count depends upon the size of a pointer (32- or 64-bit). The dimensions (1, 2, 4, 8) correspond to the Real, Complex, Quaternion, and Octonion numbers. A scalar number in a specific dimension has as many coefficients (the Basic Types) as the dimension. The Multiple-precision types '''__mpq_struct''' and '''__mpfr_struct''' are defined in '''mpir.h''' and '''mpfr.h''', respectively. The struct for '''__mpq_struct''' is defined as two '''__mpz_struct'''s, one for the numerator and one for the denominator where '''__mpz_struct''' represents a Multiple-precision Integer and is defined in '''mpir.h'''.

For example, the data portion of
* A Real Integer array has one 64-bit integer for each element.
* A Complex Multiple-precision Integer/Rational array has two '''__mpq_struct''' Basic Types per element.
* A Quaternion Multiple-precision Floating Point array has four '''__mpfr_struct''' Basic Types per element.

===Nested Arrays===

Nested Arrays ('''ARRAY_NESTED''') use the common header as above. The data portion of a Nested Array consists of a series of pointers (either 32- or 64-bit depending upon the width of the ABI (Application Binary Interface) of the program as 32- or 64-bit). As each pointer is on at least a 32-bit boundary, the low-order bit (normally 0) is used to distinguish STEs (Symbol Table Entries) from Global pointers. In an STE pointer the low-order bit is 0 and in Global pointers it is 1. A STE pointer is then an index into the current Symbol Table and a Global pointer (with the low-order bit cleared) is a global memory handle which may be locked and unlocked using '''MyGlobalLock''' and '''MyGlobalUnlock'''.

===Heterogeneous Arrays===

Heterogeneous arrays ('''ARRAY_HETERO''') are a subset of Nested Arrays in that the pointers are all to Symbol Table Entries, that is the low-order bit in the pointer is 0.

===Arithmetic Progression Arrays===

APAs ('''ARRAY_APA''') are a superset of APVs (Arithmetic Progression Vectors) in that they may be of any Shape and Rank. The header portion is as above. The data portion is defined in '''datatype.h''' as follows:

<pre>// Define APA structure
typedef struct tagAPLAPA // Offset + Multiplier {times} {iota} NELM (origin-0)
{
APLINT Off, // 00: Offset
Mul; // 08: Multiplier
// 10: Length
} APLAPA, * LPAPLAPA;
</pre>

The Multiplier may be 0 as, for example, is produced by the Reshape function of a simple scalar integer.

==Type Demotion==

All arrays are subject to type Demotion where a pointer to a '''token''' containing the array is passed to the '''TypeDemote (LPTOKEN, UBOOL)''' function and the Token is then changed. Tokens are defined in '''tokens.h'''. The '''UBOOL''' parameter specifies whether or not the dimension (1, 2, 4, 8) of the array may demoted (only if the appropriate imaginary parts are zero). This value is '''FALSE''' except in very special circumstances.

[[Category:NARS 2000]]

Control Structures

2019-10-13T22:53:51Z

Paul Robinson: t/c

== Overview ==

<table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td>
<table border="0" cellpadding="5" cellspacing="0" summary="">

<tr valign="top">
<td><apll>:for varname :in expr ⋄ </apll>...<apll> ⋄ :endfor</apll></td>
<td></td>
<td></td>
<td>Loop through the elements of expr assigning each value to varname, and then execute the statements between <apll>:for</apll> and <apll>:endfor</apll>.</td>
</tr>

<tr valign="top">
<td><apll>:forlcl varname :in expr ⋄ </apll>...<apll> ⋄ :endforlcl</apll></td>
<td></td>
<td></td>
<td>Same as <apll>:for</apll> except that the <apll>varname</apll> is localized to the <apll>:forlcl</apll> / <apll>:endforlcl</apll> control structure.</td>
</tr>

<tr valign="top">
<td><apll>:goto expr</apll></td>
<td></td>
<td></td>
<td>Execute <apll>{goto}expr</apll>.</td>
</tr>

<tr valign="top">
<td><apll>:if expr ⋄ </apll>...<apll> ⋄ :endif</apll></td>
<td></td>
<td></td>
<td>Execute the statements between <apll>:if</apll> and <apll>:endif</apll> iff expr is <apll>1</apll>.</td>
</tr>

<tr valign="top">
<td><apll>:repeat ⋄ </apll>...<apll> ⋄ :endrepeat</apll></td>
<td></td>
<td></td>
<td>Repeatedly execute the statements between <apll>:repeat</apll> and <apll>:endrepeat</apll>.</td>
</tr>

<tr valign="top">
<td><apll>:repeat ⋄ </apll>...<apll> ⋄ :until expr</apll></td>
<td></td>
<td></td>
<td>Repeatedly execute the statements between <apll>:repeat</apll> and <apll>:until</apll> until expr is <apll>0</apll>.</td>
</tr>

<tr valign="top">
<td><apll>:return</apll></td>
<td></td>
<td></td>
<td>Execute <apll>{goto}0</apll>.</td>
</tr>

<tr valign="top">
<td><apll>:select expr1 ⋄ :case expr2 ⋄ </apll>...<apll> </apll> <apll> ⋄ :caselist expr3 ⋄ </apll>...<apll> ⋄ :endselect</apll></td>
<td></td>
<td></td>
<td>Execute a specific block of statements depending upon which <apll>:case</apll> or <apll>:caselist</apll> expression matches expr1.</td>
</tr>

<tr valign="top">
<td><apll>:switch expr1 ⋄ :case expr2 ⋄ </apll>...<apll> </apll> <apll> ⋄ :caselist expr3 ⋄ </apll>...<apll> ⋄ :endswitch</apll></td>
<td></td>
<td></td>
<td>Same as <apll>:select</apll>.</td>
</tr>

<tr valign="top">
<td><apll>:while expr ⋄ </apll>...<apll> ⋄ :endwhile</apll></td>
<td></td>
<td></td>
<td>Repeatedly execute the statements between <apll>:while</apll> and <apll>:endwhile</apll> while expr is <apll>1</apll>.</td>
</tr>

<tr valign="top">
<td><apll>:while expr1 ⋄ </apll>...<apll> ⋄ :until expr2</apll></td>
<td></td>
<td></td>
<td>Repeatedly execute the statements between <apll>:while</apll> and <apll>:until</apll> while expr1 is <apll>1</apll> and expr2 is <apll>0</apll>.</td>
</tr>
</table>
</td>
</tr>
</table>
 

<ul>
<li>All Control Structures may be placed all or partly on one line as in <apll>:for I :in {iota}12 ⋄ </apll>...<apll> ⋄ :endfor</apll> (very convenient for use in immediate execution mode), or on multiple lines as in 
<apll>:for I :in {iota}12</apll> 
... 
<apll>:endfor</apll></li>

<li>As usual for any statement, a label may be used at the beginning of any line even if it starts with a Control Structure. For example, 

<apll>[3] L1::if I < 10 ⋄ </apll>...</li>

<li>Each Control Structure that closes with a statement-specific keyword (<apll>:endfor</apll>, <apll>:endforlcl</apll>, <apll>:endif</apll>, <apll>:endrepeat</apll>, <apll>:endselect</apll>, <apll>:endswitch</apll>, and <apll>:endwhile</apll>), may instead close with the <apll>:end</apll> keyword.</li>
</ul>
 

== FOR/FORLCL Statements ==

<table border="0" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td><apll>:for varname :in expr</apll></td>
<td style="border-right: solid 1px black;"></td>
<td></td>
<td><apll>:forlcl varname :in expr</apll></td>
</tr>

<tr>
<td>... (Block of statements)</td>
<td style="border-right: solid 1px black;"></td>
<td></td>
<td>... (Block of statements)</td>
</tr>

<tr>
<td><apll>:endfor</apll></td>
<td style="border-right: solid 1px black;"></td>
<td></td>
<td><apll>:endforlcl</apll></td>
</tr>
</table>

These statements evaluate expr once, loop through its elements, assign each successive value to <apll>varname</apll>, and then execute the block of statements once for each value in expr. The expr may be of any type (including character and nested), any rank, and any shape. If expr is empty, the block of statements is skipped.

With the <apll>:for</apll> statement, the <apll>varname</apll> is not localized to the <apll>:for</apll> loop; upon exiting the loop, <apll>varname</apll> has the last value assigned to it by the <apll>:for</apll> loop.

With the <apll>:forlcl</apll> statement, the <apll>varname</apll> is localized to the <apll>:forlcl</apll> loop; upon exiting the loop, <apll>varname</apll> has the value assigned to it before the <apll>:forlcl</apll> loop started.

To interrupt the flow of control within a block of statements, use the <apll>:continue</apll> or <apll>:leave</apll> keywords. The former keyword transfers control to the end of the block continuing with the next iteration, thus skipping the statements between the <apll>:continue</apll> and matching <apll>:endfor</apll>/<apll>:endforlcl</apll> keywords. The latter keyword exits the <apll>:for</apll>/<apll>:forlcl</apll> loop entirely and transfers control to the statement after the matching <apll>:endfor</apll>/<apll>:endforlcl</apll> statement. Typically, these two keywords appear within <apll>:if</apll>/<apll>:endif</apll> statements.

== GOTO Statement ==

<apll>:goto expr</apll>

This statement transfers control to the line number specified in expr. The value of expr must be a numeric simple scalar or one-element vector. This statement is equivalent to <tt>[[→]]expr</tt>.

== IF Statement ==

<apll>:if expr1</apll> 
... (Block of statements) 
<apll>:elseif expr2</apll> 
... (Block of statements) 
<apll>:else</apll> 
... (Block of statements) 
<apll>:endif</apll>

This statement conditionally executes a block of statements.

Each expression must evaluate to a Boolean-valued scalar or one-element vector.

Each <apll>:if</apll> and <apll>:elseif</apll> statement may be followed by zero or more statements which form the block of statements controlled by that statement.

The <apll>:if</apll> statement may be followed by zero or more <apll>:elseif</apll> blocks. Optionally, the <apll>:else</apll> statement may appear after all <apll>:elseif</apll> statements to handle the case where none of the previous expressions was true (evaluated to a <apll>1</apll>).

Each <apll>:if</apll> and <apll>:elseif</apll> statement may be followed by zero or more <apll>:andif</apll> statements to narrow the conditions under which the following block of statements is executed, or may be followed by zero or more <apll>:orif</apll> statements to widen the conditions under which the following block of statements is executed. The <apll>:andif</apll> and <apll>:orif</apll> statements may not be mixed within any <apll>:if</apll> or <apll>:elseif</apll> statement.

== REPEAT Statement ==

<table border="0" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td><apll>:repeat</apll></td>
<td style="border-right: solid 1px black;"></td>
<td></td>
<td><apll>:repeat</apll></td>
</tr>

<tr>
<td>... (Block of statements)</td>
<td style="border-right: solid 1px black;"></td>
<td></td>
<td>... (Block of statements)</td>
</tr>

<tr>
<td><apll>:endrepeat</apll></td>
<td style="border-right: solid 1px black;"></td>
<td></td>
<td><apll>:until expr</apll></td>
</tr>
</table>

This statement executes a block of statements repeatedly (but at least once) until the <apll>:until</apll> expression is true, or control transfers out of the Control Structure.

In the righthand form above, the block of statements is executed and then the expression is executed. It must evaluate to a Boolean-valued scalar or one-element vector. If the expression is true, the Control Structure terminates and execution continues with the statement after the <apll>:until</apll> statement; if the expression is false, execution continues at the start of the Control Structure.

The <apll>:until</apll> statement may be followed by zero or more <apll>:andif</apll> statements to widen the conditions under which the block of statements is executed, or it may be followed by zero or more <apll>:orif</apll> statements to narrow the conditions under which the block of statements is executed. The <apll>:andif</apll> and <apll>:orif</apll> statements may not be mixed after an <apll>:until</apll> statement.

To interrupt the flow of control within a block of statements, use the <apll>:continue</apll> or <apll>:leave</apll> keywords. The former keyword transfers control to the end of the block continuing with the next repetition, skipping the statements between the <apll>:continue</apll> and matching <apll>:endrepeat</apll> or <apll>:until</apll> keywords. The latter keyword exits the <apll>:repeat</apll> loop entirely and transfers control to the statement after the matching <apll>:endrepeat</apll> or <apll>:until</apll> statement. Typically, these two keywords appear within <apll>:if</apll> statements.

== RETURN Statement ==

<apll>:return</apll>

This statement exits the current function and is equivalent to <apll>→0</apll>.

== SELECT/SWITCH Statements ==

<table summary="">
<tr>
<td>
<apll>:select expr1</apll> 
<apll>:case expr2</apll> 
... (Block of statements) 
<apll>:caselist expr3</apll> 
... (Block of statements) 
<apll>:else</apll> 
... (Block of statements) 
<apll>:endselect</apll>
</td>
<td>   OR   </td>
<td>
<apll>:switch expr1</apll> 
<apll>:case expr2</apll> 
... (Block of statements) 
<apll>:caselist expr3</apll> 
... (Block of statements) 
<apll>:else</apll> 
... (Block of statements) 
<apll>:endswitch</apll>
</td>
</tr>
</table>

This statement provides a mechanism for making a choice from multiple cases as to which block of statements is executed. The <apll>:select</apll> statement expression is evaluated and compared against each successive <apll>:case</apll> expression and the successive items in each <apll>:caselist</apll> expression. Control is given to the first block of statements whose corresponding expression (or expression item in the case of <apll>:caselist</apll>) matches the <apll>:select</apll> expression.

For the <apll>:case</apll> statement, its expression is compared with the <apll>:select</apll> statement's expression. The comparison uses the Match function (≡), so it takes into account rank and shape at every level.

For the <apll>:caselist</apll> statement, the successive items in its expression are compared with the <apll>:select</apll> statement's expression. As with the <apll>:case</apll> statement the comparison uses the Match function. The <apll>:case</apll> statements allows you to combine multiple selection criteria into one expression. It is equivalent to the C language use of multiple case statements preceding a block of statements.

Unlike the C language switch statement, the <apll>:case</apll> and <apll>:caselist</apll> expressions need not be constant, and there may be multiple <apll>:case</apll> or <apll>:caselist</apll> statements whose expressions evaluate to the same value — however only the earliest occurrence is selected.

When the last statement in a block of statements is executed, the system exits the <apll>:select</apll> control structure. The <apll>:leave</apll> statement may be used to exit that block before reaching the last statement, similar to the C language break statement.

Each <apll>:case</apll> and <apll>:caselist</apll> statement may be followed by zero or more statements which form the block of statements controlled by that statement.

The <apll>:select</apll> statement may be followed by a mixture of zero or more <apll>:case</apll> and <apll>:caselist</apll> blocks. Optionally, the <apll>:else</apll> statement may appear after all <apll>:case</apll> and <apll>:caselist</apll> statements to handle the case where none of the previous <apll>:case</apll> or <apll>:caselist</apll> expressions match the <apll>:select</apll> expression — in this context, the <apll>:else</apll> statement is similar to the C language default statement.

Because of the way <apll>:select</apll> statements are executed, a line with a <apll>:case</apll> or <apll>:caselist</apll> statement may not be a branch target; otherwise a <apll>DESTINATION ERROR</apll> is signaled. That is, a <apll>:select</apll> statement may be entered at the top only.

<apll>:switch</apll> is an alias for <apll>:select</apll>; in the above discussion wherever <apll>:select</apll> appears, you may substitute <apll>:switch</apll>.
 
== Cases Branching Example 1 ==
As an alternative to the Select/Switch control structure(s) above, for a pure original APL solution to Multiple Cases scenarios in a user-function, consider using the following APL control structure. For example the following user-function, has one local variable (boolCases) with 6 different cases handled: 
BranchingExample1;boolCases 
[1] ⍝MULTIPLE CASES: Branching/GoTo Example #1 
[2] boolCases←0 1 1 1 0 0       ⍝Leftmost boolean 1 determines which case or block will be executed { 0 1 1 1 0 0 } 
[3] →boolCases/(Label1 Label2 Label3 Label4 Label5 Label6) 
[4] 'Did NOT branch, Case ELSE.' 
[5] →Next1 
[6] Label1: 'Do this, Label1' 
[7] →Next1 
[8] Label2: 'Do this, Label2'         ⍝This case will get branched to based on boolCases! 
[9] →Next1 
[10] Label3: 'Do this, Label3' 
[11] →Next1 
[12] Label4: 'Do this, Label4' 
[13] →Next1 
[14] Label5: 'Do this, Label5' 
[15] →Next1 
[16] Label6: 'Do this, Label6' 
[17] Next1: 'Code continues here.' 
 
        BranchingExample1       ⍝User-session, BranchingExample1 ''typed in by user''. 
Do this, Label2 
Code continues here. 


== WHILE Statement ==

<table border="0" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td><apll>:while expr1</apll></td>
<td style="border-right: solid 1px black;"></td>
<td></td>
<td><apll>:while expr1</apll></td>
</tr>

<tr>
<td>... (Block of statements)</td>
<td style="border-right: solid 1px black;"></td>
<td></td>
<td>... (Block of statements)</td>
</tr>

<tr>
<td><apll>:endwhile</apll></td>
<td style="border-right: solid 1px black;"></td>
<td></td>
<td><apll>:until expr2</apll></td>
</tr>
</table>

This statement executes a block of statements repeatedly until the <apll>:while</apll> expression is false, or the <apll>:until</apll> expression is true, or control transfers out of the Control Structure.

The expressions must evaluate to a Boolean-valued scalar or one-element vector.

In the righthand form above, if the <apll>:while</apll> expression evaluates to a scalar or one-element vector whose value is <apll>1</apll>, the block of statements is executed and then the <apll>:until</apll> expression is executed. It must evaluate to a Boolean-valued scalar or one-element vector. If the <apll>:until</apll> expression is true, the Control Structure terminates and execution continues with the statement after the <apll>:until</apll> statement; if the <apll>:until</apll> expression is false, execution continues at the start of the Control Structure.

The <apll>:while</apll> statement may be followed by zero or more <apll>:andif</apll> statements to narrow the conditions under which the block of statements is executed, or it may be followed by zero or more <apll>:orif</apll> statements to widen the conditions under which the block of statements is executed. The <apll>:andif</apll> and <apll>:orif</apll> statements may not be mixed after a <apll>:while</apll> statement.

The <apll>:until</apll> statement may be followed by zero or more <apll>:andif</apll> statements to widen the conditions under which execution the block of statements is executed, or it may be followed by zero or more <apll>:orif</apll> statements to narrow the conditions under which the block of statements is executed. The <apll>:andif</apll> and <apll>:orif</apll> statements may not be mixed after an <apll>:until</apll> statement.

To interrupt the flow of control within a block of statements, use the <apll>:continue</apll> or <apll>:leave</apll> keywords. The former keyword transfers control to the end of the block continuing with the next repetition, skipping the statements between the <apll>:continue</apll> and matching <apll>:endwhile</apll> or <apll>:until</apll> keywords, but evaluating and acting upon an <apll>:until</apll> statement, if present. The latter keyword exits the <apll>:while</apll> loop entirely and transfers control to the statement after the matching <apll>:endwhile</apll> or <apll>:until</apll> statement. Typically, these two keywords appear within <apll>:if</apll> statements.

[[Category:Examples]]

Control Structures

2019-10-13T22:52:50Z

Paul Robinson: /* WHILE Statement */

Composition

2019-10-13T22:50:02Z

Paul Robinson: t/c

<table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td>
<table border="0" cellpadding="5" cellspacing="0" summary="">
<tr>
<td valign="top"><apll>Z←L f⍥g R</apll></td>
<td></td>
<td></td>
<td>returns <apll>(g L) f g R</apll>.</td>
</tr>
</table>
</td>
</tr>
<tr>
<td><apll>L</apll> and <apll>R</apll> are arrays.</td>
</tr>
<tr>
<td><apll>f</apll> and <apll>g</apll> are functions.</td>
</tr>
</table>

[[Category:Examples]]

Another Approach To Building

2019-10-13T22:47:51Z

Paul Robinson: t/c

== Need to set some system environment variables: ==

Right click on My Computer and select Properties. Then select
the "Advanced" tab and then press the "Environment Variables" button.
Add or verify these system environment variables.

<pre>
REM Visual Studio 2008 C/C++ compiler
MSVC <-- C:\Program Files\Microsoft Visual Studio 9.0\VC\

REM Contains BISON and GREP
PARDIR <-- C:\tools\GnuWin32

REM Bison Parser Generator
PARGEN <-- C:\tools\GnuWin32\bin\bison.exe

PATH <-- %PARDIR%\bin;C:\tools\PHP\;%PATH%

REM PHP Resource Compile
PHPRC <-- C:\tools\PHP\

REM Windows SDK
SDK <-- C:\Program Files\Microsoft SDKs\Windows\v6.0A\

REM Set by Visual Studio 2008 install
REM Need to access NMAKE
VS90COMNTOOLS <-- c:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\

REM 7-zip file compression
REM double quotes required
ZIPPRG <-- "C:\Program Files\7-Zip\7z.exe"
</pre>

== Modify mk32.bat and mkd32.bat ==

<pre>
REM comment out "@echo off"
REM Add the call vsvars32.bat to set more Visual Studio 2008 environment
rem @echo off
call "%VS90COMNTOOLS%vsvars32.bat"
</pre>

== Install PHP, 7-zip, Bison, and Grep On Windows ==

'''PHP'''

[http://php.net/downloads.php PHPMainPage]

[http://windows.php.net/download/ PHPForWindows]

'''7-zip'''

[http://www.7-zip.org/download.html Get7Zip]

'''Bison'''

[http://gnuwin32.sourceforge.net/packages/bison.htm GetWinBison]

'''Grep'''

[http://sourceforge.net/projects/gnuwin32/files/ GetWinGrep]

== Double Quote Some NMAKE Vars In makefile.w32 ==

This make it so Windows filenames with spaces work, such as C:\Program Files\...

<pre>
Change

LD=$(MSVC)bin\link.exe
CC=$(MSVC)bin\cl.exe
RC=$(SDK)Bin\rc.exe
ML=$(MSVC)bin\ml.exe

to

LD="$(MSVC)bin\link.exe"
CC="$(MSVC)bin\cl.exe"
RC="$(SDK)Bin\rc.exe"
ML="$(MSVC)bin\ml.exe"
</pre>

== Set up qdebug ==

<pre>
Need to get the qdebug files in

<proj_root>\RET\D32\qdebug

and

<proj_root>\RET\ND32\qdebug

The three files are:

QDebug.pro
QDEBUG32.DLL
QDEBUG32.LIB

These come in the NARS2000 developer tools in the file:

qdebug.zip

</pre>

You have to click on the "Display All Files" button to see these tools at:

[http://www.nars2000.org/download/Download.html DevTools]

== Put the GNU Scientific Library in <proj_root>/gsl ==

<pre>
Unzip

gsldir.zip

and copy the contents of the

gsl\include\gsl

subdirectory to

<proj_root>\gsl

Now copy

gsl\libgsl32-double.lib

and

\gsl\libgsl64-double.lib

to

<proj_root>\gsl

</pre>

To get NARS2000 developer tool in the file gsldir.zip you have to click on the "Display All Files" button to see these tools at:

[http://www.nars2000.org/download/Download.html|http://www.nars2000.org/download/Download.html DevTools]

--[[User:AlanG01|AlanG01]] 00:49, 29 December 2009 (UTC)

[[Category:NARS 2000]]

Category:Examples

2019-10-13T22:44:25Z

Paul Robinson: new

These pages explain how to use APL or how to write code using it.

Compose

2019-10-13T22:42:10Z

Paul Robinson:

In the following descriptions, <apll>f</apll> and <apll>g</apll> represent functions and <apll>a</apll> and <apll>b</apll> represent variables.

* The form <apll>f∘g</apll> may be used both monadically and dyadically.
:
:Monadic: <apll>Z←f∘g R</apll> is identical to <apll>Z←fg R</apll>.
:
:Dyadic: <apll>Z←L f∘g R</apll> is identical to <apll>Z←L fg R</apll>.

* The form <apll>f∘b</apll> may be used monadically only.
:
:Monadic: <apll>Z←(f∘b) R</apll> is identical to <apll>Z←R f b</apll>.
:Note that parentheses are required around the function to avoid interpreting <apll>b R</apll> as a strand.

* The form <apll>a∘g</apll> may be used monadically only, unless <apll>g</apll> is any of <apll>/</apll>, <apll>⌿</apll>, <apll>/[X]</apll>, <apll>\</apll>, <apll>⍀</apll>, or <apll>\[X]</apll>.
:
:Monadic: <apll>Z←a∘g R</apll> is identical to <apll>Z←a g R</apll>.
:
:Dyadic: <apll>Z←L (a∘/) R</apll> (and its related variants <apll>⌿</apll> and <apll>/[X]</apll>) is called '''Mask''' (see below).
:
:Dyadic: <apll>Z←L (a∘\) R</apll> (and its related variants <apll>⍀</apll> and <apll>\[X]</apll>) is called '''Mesh''' (see below).

* The derived function from the form <apll>a∘b</apll> always signals a <apll>SYNTAX ERROR</apll>.

Compose can be useful for function assignment (but enclosing parentheses are necessary).

For example

<apll><pre>
p1←(1∘+¯2∘π) ⍝ 1 more than the Nth prime number
p1 ⍳9
3 4 6 8 12 14 18 20 24
</pre></apll>

==Mask==
<table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td>
<table border="0" cellpadding="5" cellspacing="0" summary="">
<tr>
<td valign="top"><apll>Z←L (a∘/) R</apll> <apll>Z←L (a∘⌿) R</apll> <apll>Z←L (a∘/[X]) R</apll></td>
<td></td>
<td></td>
<td valign="top">each returns '''some''' items '''in order but interleaved''' from the left and right arguments, possibly repeated multiple times and possibly omitting values from both arguments, combined into a single result, according to the values in <apll>a</apll>.</td>
</tr>
</table>
</td>
</tr>
<tr>
<td><apll>L</apll> is an array of arbitrary rank.</td>
</tr>
<tr>
<td><apll>a</apll> is a scalar or vector of integers.
</tr>
<tr>
<td><apll>R</apll> is an array of arbitrary rank.</td>
</tr>
<tr>
<td><apll>[X]</apll> is the optional Axis along which the function is applied — if this option is omitted, the function is applied along the rightmost axis.</td>
</tr>
<tr>
<td>Either or both of <apll>L</apll> and <apll>R</apll> can be scalars in which case the scalar is reshaped to the shape of the other argument. Otherwise, the two arguments must be of the same rank and shape.</td>
</tr>
<tr>
<td>After <apll>L</apll> and <apll>R</apll> have been scalar extended, if <apll>a</apll> is a scalar, it is extended to be the same length as the common coordinate in the arguments. Otherwise, <apll>a</apll> must be a vector of the same length as <apll>(⍴L)[X]</apll> (or, equivalently, <apll>(⍴R)[X]</apll>).</td>
</tr>
</table>

The function '''Mask''' selects '''some''' items from the left and right arguments depending upon the Left Operand (<apll>a</apll>). For vector arguments, if <apll>a[I]</apll> is '''negative''', it selects the <apll>I</apll>th item from <apll>L</apll>; if it is '''positive''' it selects the <apll>I</apll>th item from <apll>R</apll>; if it is '''zero''', the <apll>I</apll>th items from <apll>L</apll> and <apll>R</apll> are ignored. The absolute value of <apll>a[I]</apll> indicates how many copies of the selected item are placed into the result.

For this function, the position in <apll>a</apll> (e.g., first, second, third, ...) indicates which item of the arguments (e.g., first, second, third, ...) is selected. The sign of the integer in <apll>a</apll> indicates whether it's the left argument ('''negative'''), right argument ('''positive'''), or neither ('''zero''').

For example,

<apll><pre>
'ABC' (¯1 3 ¯2∘/) 'abc'
AbbbCC
(3 3⍴⎕A) (¯1 3 ¯2∘/) 3 3⍴⎕a
AbbbCC
DeeeFF
GhhhII
(3 3⍴⎕A) (¯1 3 ¯2∘⌿) 3 3⍴⎕a
ABC
def
def
def
GHI
GHI
(3 3⍴⎕A) (¯1 0 ¯2∘⌿) 3 3⍴⎕a
ABC
GHI
GHI
(3 3⍴⎕A) (¯1 0 ¯2∘/) 3 3⍴⎕a
ACC
DFF
GII
</pre></apll>

This function is essentially equivalent to

<apll>(|LO~0)/[X] (⊂(⍋×LO,-LO)[⍋⍋×LO~0])⌷[X] L,[X] R</apll>

where <apll>LO</apll> is the Left Operand <apll>a</apll>.

==Mesh==
<table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td>
<table border="0" cellpadding="5" cellspacing="0" summary="">
<tr>
<td valign="top"><apll>Z←L (a∘\) R</apll> <apll>Z←L (a∘⍀) R</apll> <apll>Z←L (a∘\[X]) R</apll></td>
<td></td>
<td></td>
<td valign="top">each returns '''all''' items '''in order but interleaved''' from the left and right arguments, possibly repeated multiple times and possibly including the right argument's fill element, combined into a single result, according to the values in <apll>a</apll>.</td>
</tr>
</table>
</td>
</tr>
<tr>
<td><apll>L</apll> is an array of arbitrary rank.</td>
</tr>
<tr>
<td><apll>a</apll> is a scalar or vector of integers.
</tr>
<tr>
<td><apll>R</apll> is an array of arbitrary rank.</td>
</tr>
<tr>
<td><apll>[X]</apll> is the optional Axis along which the function is applied — if this option is omitted, the function is applied along the rightmost axis.</td>
</tr>
<tr>
<td>If <apll>L</apll> and <apll>R</apll> are both vectors, their lengths are related to the values in <apll>a</apll> and the result <apll>Z</apll> as follows:
<apll>⍴L ←→ +/a<0
⍴R ←→ +/a>0
⍴Z ←→ +/1⌈|a</apll>

If either <apll>L</apll> or <apll>R</apll> is a scalar, it is reshaped to the shape of the other argument, except for the implicit or explicit Axis dimension whose length follows the above rules for vectors. Otherwise, the two arguments must have identical shape except for the Axis dimension whose length follows the above rules for vectors.
</td>
</tr>
</table>

The function '''Mesh''' selects '''all''' items from the left and right arguments depending upon the Left Operand (<apll>a</apll>). For vector arguments, the values in the Left Operand are organized into the '''negative''', '''zero''', and '''positive''' values. As the above rules indicate, the length of the left argument is equal to the number of '''negative''' values in the Left Operand, and the length of the right argument is equal to the number of '''positive''' values. This means that every element of the left and right arguments appears in the result. In particular, the <apll>I</apll>th item from the left argument appears in the result corresponding to the position of the <apll>I</apll>th '''negative''' item in <apll>a</apll>, and the <apll>I</apll>th item from the right argument appears in the result corresponding to the position of the <apll>I</apll>th '''positive''' item in <apll>a</apll>. The absolute value of the item from the Left Operand indicates how many times the corresponding item from the chosen argument is repeated in the result. A '''zero''' in the Left Operand causes the right argument's fill element to appear in the result.

For example, <apll>'I' (1 ¯1 2 ¯1 2 ¯1 2 ¯1 ∘\) 'MSSP' ←→ 'IIII' (1 ¯1 2 ¯1 2 ¯1 2 ¯1 ∘\) 'MSSP'</apll> because there are four '''negative''' items in the Left Operand.

<apll><pre>
'I' (1 ¯1 2 ¯1 2 ¯1 2 ¯1 ∘\) 'MSSP'
MISSISSIPPI
'BIB' (¯1 ¯1 1 ¯1 1 0 1 1 2 1 1 1 ∘\) 'LOBAGINS'
BILBO BAGGINS
(3 3⍴⎕A) (1 ¯1 2 ¯2 3 ¯3∘\[2]) 3 3⍴⎕a
aAbbBBcccCCC
dDeeEEfffFFF
gGhhHHiiiIII
(3 3⍴⎕A) (1 ¯1 2 ¯2 3 ¯3∘⍀) 3 3⍴⎕a
abc
ABC
def
def
DEF
DEF
ghi
ghi
ghi
GHI
GHI
GHI
</pre></apll>

This function is essentially equivalent to

<apll>(|LO)\[X] (⊂⍋⍋×LO~0)⌷[X] L,[X] R</apll>

where <apll>LO</apll> is the Left Operand <apll>a</apll>. Note that this definition is dependent upon extending the Expand function to (Signed) Integer Left Arguments as in

<apll><pre>
2 ¯2 1 0 2\'ABC'
AA B CC
</pre></apll>

[[Category:Examples]]

Category:Monadic operators

2019-10-13T22:38:31Z

Paul Robinson: new

System or user functions and APL operators that are ''[[monadic]]'', are those that take one argument, one or more values to the right of the operator or function.

Template:SFDM

2019-10-13T22:33:46Z

Paul Robinson: t/c

Note: <big>⎕{{{1}}}</big> is available as both a ''[[monadic]]'' and ''[[dyadic]]'' form system function, you cannot assign a value to it.
{{System Variables}}
{{Article footer|0|NO}}<includeonly>[[Category:Dyadic operators|{{{1}}}]] [[Category:Monadic operators|{{{1}}}]]</includeonly>
<noinclude>
{{SF/doc}}
[[Category:Navigation]]
</noinclude>

Category:Dyadic operators

2019-10-13T22:30:44Z

Paul Robinson: t/c

System or user functions and APL operstors that are ''[[dyadic]]'', are those that take two arguments, one or more to the left of the operator or function, and one or more to its right.

Category:Dyadic operators

2019-10-13T22:29:53Z

Paul Robinson: new

System or user functions and APL operstors that are ''[[diadic]]'', are those that take two arguments, one or more to the left of the operator or function, and one or more to its right.

Dyadic

2019-10-13T22:24:00Z

Paul Robinson: explain & add cat

A '''dyadic''' function is one that takes an argument on the left and right of the function. Here is an example of a dyadic function named '''deal''' to deal hands of cards: 
<apll>    ∇ k ← count deal cards;c 
[1]   c ← count 
[2]   k ←'' 
[3]   Q: 
[4]   k ← k, cards ? 52 
[5]   c ← c-1 
[6]   →(c>0)/Q 
[7]   k←count cards ⍴ k 
    ∇ 
</apll>
So an execution of this function to deal 6 hands of 7 cards could produce the following: 
<apll>      6 deal 7 
 28  1  8 24 32 47 27 
 38 46  1 43  3 40  7 
 47 28 26  7 39  2 37 
 36 12 48 46 47 31 13 
 24 52 13 25 20 30 47 
 23 25 43 21 15 52 14 </apll>

The numbers generated would have to be related to a rank and suit to display a particular card.

Some system functions are dyadic, in that you may present them one argument on each side of the function name, and it may return a value. The [[System Function FMT|{quad}FMT]] function provides specialized formatting when used as a dyadic function.

== See Also==
* [[niladic]] (accepts no arguments)
* [[monadic]] (accepts one argument)
* [[dyadic]] (accepts two arguments)
 <hr/>
{{Article footer|0|NO}}
[[Category:Definitions]]
[[Category:Dyadic operators]]

Monadic

2019-10-13T22:22:01Z

Paul Robinson: t/c

A function is '''monadic''' if it accepts an argument to the right of the function. For example:

<code>'''<big>    ∇ z{:=}dealcard m 
[1]    z←m ? 52 
    ∇ </big>'''</code>

In this case, the function would return a shuffle of '''m''' cards from a deck of 52. So a statement of
: shuffle {:=} dealcard 7
Would set '''shuffle''' to the value of an array of 7 entries in the range of 1 to 52. Or to visualize: 
<apll>      dealcard 7 
33 1 3 4 42 40 21 </apll>
To make this related to a deck of cards you'd have to relate the numbers to the rank and suit.

An 'argument' can be an array or string or whatever the function is willing to accept.

Some System functions are monadic in that you may present them one argument, and it may return a value. The [[System Function DL|{quad}DL]] function delays execution for an amount of time indicated by the argument.

== See Also==
* [[niladic]] (accepts no arguments)
* [[monadic]] (accepts one argument)
* [[dyadic]] (accepts two arguments)
 <hr/>
{{Article footer|0|NO}}
[[Category:Definitions]]

System Function FMT

2019-10-13T22:20:28Z

Paul Robinson: t/c

==Monadic Function==

<table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td>
<table border="0" cellpadding="5" cellspacing="0" summary="">
<tr>
<td valign="top"><apll>Z←⎕FMT R</apll></td>
<td></td>
<td></td>
<td>returns a representation of <apll>R</apll> formatted within boxes.</td>
</tr>
</table>
</td>
</tr>
<tr>
<td><apll>R</apll> is an arbitrary array.</td>
</tr>
<tr>
<td><apll>Z</apll> is a Character MATRIX which reveals the array structure and types of the elements of <apll>R</apll>.</td>
</tr>

</table>
 

For example,

<pre>
⎕fmt ⍳3
┌3────┐
│1 2 3│
└~────┘
⎕fmt ⍳¨⍳3
┌3──────────────────┐
│ ┌1┐ ┌2──┐ ┌3────┐ │
│ │1│ │1 2│ │1 2 3│ │
│ └~┘ └~──┘ └~────┘ 2
└∊──────────────────┘
⎕fmt 1 1 4⍴23 'abc' '*' (2 3⍴⍳6)
┌┬4────────────────────┐
11 ┌3──┐ ┌3─────┐ │
││ 23 │abc│ * 2 1 2 3│ │
││ ~~ └───┘ ¯ │ 4 5 6│ │
││ └~─────┘ 2
└┴∊────────────────────┘
</pre>

This function is implemented via the Magic Functions <apll>#MonFMT</apll> and <apll>#Box</apll>. The design is based upon ideas from Rabenhorst1.

1 [http://portal.acm.org/citation.cfm?id=55664 "The Compact Display of Arbitrary Nested Arrays"] D. A. Rabenhorst (IBM), APL88 Conference Proceedings, pp 272-277, ACM.

<hr width=55%>
APL code for Magic Function #BoxFMT(July 2015):
<pre>
2 ⎕CR '#BoxFMT'
Z←Z #BoxFMT R;RD;LD;D
LD←⍕(0≠⍴⍴R)/¯1↑⍴R
RD←⍕⍪¯1↓⍴R
RD←(+/RD=' ')⌽RD
D←¯2+⍴⍴Z
:if D>0
:while 2<⍴⍴Z
Z←,[¯3 ¯2] Z,[¯2]' '
:endwhile
Z←(-D)↓[0]Z
:endif
Z←(¯2↑1,⍴Z)⍴Z ⋄ Z←((⍴Z)⌈(¯1↑⍴RD),⍴LD)↑Z
:if 1≥⍴⍴R
RD←((1↑⍴Z),1)⍴'│'
:else
RD←⍉(1↑⍴Z)↑[1] RD ⋄ RD[(,RD=' ')/,⍳⍴RD]←'│'
:endif
RD←'┬'⍪RD⍪'┴' ⋄ RD[0 ¯1;0]←'┌└'
Z←Z,'│'
D←≡R
:if 1<D
D←⍕D
Z[⍳-⍴D;¯1]←⌽D
:endif
Z←'─'⍪Z⍪'─'
Z[0 ¯1;¯1]←'┐┘'
Z[0;⍳⍴LD]←LD
Z[¯1;0]←Type
Z←RD,Z
</pre>

For a list of all magic functions implemented in NARS, see [[System_Function_NL|⎕NL 23 24]]

==Dyadic Function==

<table border="1" cellpadding="5" cellspacing="0" rules="none" summary="">
<tr>
<td>
<table border="0" cellpadding="5" cellspacing="0" summary="">
<tr>
<td valign="top"><apll>Z←L ⎕FMT R</apll></td>
<td></td>
<td></td>
<td>returns the formatted representation of <apll>R</apll> as controlled by <apll>L</apll>.</td>
</tr>
</table>
</td>
</tr>
<tr>
<td><apll>R</apll> is a simple array or a nested vector of simple arrays — this is the array to be formatted.</td>
</tr>
<tr>
<td><apll>L</apll> is a character scalar or vector — this is the format specification.</td>
</tr>

</table>
 <big>'''Quad FMT''' sample ''dyadic'' usage:</big>
<big><pre>
'CI 14' ⎕FMT ⎕WA ⍝ C=use commas(",") modifier; I=Integer format; 14=reserve 14 spaces. ⎕WA=free workspace area.
50,825,084,928 ⍝ Result shown by APL, commas inserted. Easily readable, over 50 gigabytes of free work area.
'CI 13' ⎕FMT ⎕WA ⍝ Same as 1st example, but too FEW spaces allowed for(only 13); hence, APL returns all asterisks(*).
*************
'CF 14.2' ⎕FMT 44888.769 ⍝ C=Commas modifier, F=Floating point number format; 14 reserved spaces; 2 decimals. .769 to .77
44,888.77

'G<99/99/9999>' ⎕FMT 03042015 ⍝ G<...>=General picture formatting(like Cobol Gen picture fmt), in this case formatting for a date!
03/04/2015
⍴('G<99/99/9999>' ⎕FMT 03042015) ⍝ Note that OUTPUT from ⎕FMT is a Char/string MATRIX (NOT a vector), in this case a ONE ROW matrix.
1 10

'G<(999) 999-9999>' ⎕FMT 8005126200 8004443300 ⍝ Formatting for telephone numbers. Output = 2-row character matrix.
(800) 512-6200
(800) 444-3300
</pre></big>
 

Based upon the original STSC implementation in the early 1970s, this function performs a wide variety of formatting tasks such as Integer, Decimal, Exponential, Alphabetic, and Picture formatting.

The left argument consists of zero or more format phrases each separated by a comma and zero or more spaces. A format phrase consists of an optional Repetition factor, zero or more Qualifiers, zero or more Decorators, a Phrase Type, and possibly width or other numeric information depending upon the Phrase Type.
 
The list of Phrase Types consists of

<table border="1" cellpadding="5" cellspacing="0" rules = "none" summary="">
<tr>
<td><apll>A</apll>w</td>
<td>Character format</td>
</tr>
<tr>
<td><apll>E</apll>w.s</td>
<td>Exponential format</td>
</tr>
<tr>
<td><apll>F</apll>w.d</td>
<td>Decimal format</td>
</tr>
<tr>
<td><apll>G</apll><picture></td>
<td>Picture format</td>
</tr>
<tr>
<td><apll>I</apll>w</td>
<td>Integer format</td>
</tr>
<tr>
<td><apll>R</apll>w.d</td>
<td>Rational format</td>
</tr>
<tr>
<td><apll>T</apll></td>
<td>Rightmost positioning</td>
</tr>
<tr>
<td><apll>T</apll>p</td>
<td>Absolute positioning</td>
</tr>
<tr>
<td><apll>X</apll>w</td>
<td>Relative positioning where w may be negative as in <apll>X¯3</apll> or <apll>X-3</apll></td>
</tr>
</table>
 

The list of Qualifiers consists of

<table border="1" cellpadding="5" cellspacing="0" rules = "none" summary="">
<tr>
<td><apll>B</apll></td>
<td>Blank if zero</td>
</tr>
<tr>
<td><apll>C</apll></td>
<td>Comma (thousands separator) insertion</td>
</tr>
<tr>
<td><apll>K</apll>n</td>
<td>Scaling by 10n where n may be negative as in <apll>K¯3</apll> or <apll>K-3</apll></td>
</tr>
<tr>
<td><apll>L</apll></td>
<td>Left justification</td>
</tr>
<tr>
<td><apll>Z</apll></td>
<td>Zero fill</td>
</tr>
</table>
 

The list of Decorators consists of a Decorator Type followed by text, where the text is surrounded by delimiters which come in pairs such as

<apll>'...'</apll> 
<apll>"..."</apll> 
<apll>⎕...⎕</apll> 
<apll>⍞...⍞</apll> 
<apll>¨...¨</apll> 
<apll><...></apll> 
<apll>⊂...⊃</apll>

The list of Decorators consists of

<table border="1" cellpadding="5" cellspacing="0" rules = "none" summary="">
<tr>
<td><apll>M</apll><text></td>
<td>Negative left decoration</td>
</tr>
<tr>
<td><apll>N</apll><text></td>
<td>Negative right decoration</td>
</tr>
<tr>
<td><apll>O</apll><text></td>
<td>Zero substitution</td>
</tr>
<tr>
<td><apll>O</apll>n<text></td>
<td>Specific value substitution where n may be negative as in <apll>O¯2<text></apll> or <apll>O-2<text></apll></td>
</tr>
<tr>
<td><apll>P</apll><text></td>
<td>Positive and zero left decoration</td>
</tr>
<tr>
<td><apll>Q</apll><text></td>
<td>Positive and zero right decoration</td>
</tr>
<tr>
<td><apll>R</apll><text></td>
<td>Background fill</td>
</tr>
<tr>
<td><apll>S</apll><text></td>
<td>Symbol substitution</td>
</tr>
</table>
 

Within a Format Phrase, Qualifiers and Decorators may appear in any order, and may be separated from each other and the Phrase Type by zero or more spaces.

===Character Format Phrase===

Form: rqd<apll>A</apll>w

where r is an optional repetition factor, q is an optional qualifier (<apll>L</apll> only is allowed), d is an optional decorator (<apll>R</apll> and <apll>S</apll> are allowed), and w is the field width in which each character is placed, right- or left-justified as per the absence/presence of the <apll>L</apll> qualifier.

===Exponential Format Phrase===

Form: rqd<apll>E</apll>w.s

where r is an optional repetition factor, q is an optional qualifier (<apll>B</apll>, <apll>K</apll>, <apll>L</apll>, and <apll>Z</apll> are allowed), d is an optional decorator (<apll>M</apll>, <apll>N</apll>, <apll>O</apll>, <apll>P</apll>, <apll>Q</apll>, <apll>R</apll>, and <apll>S</apll> are allowed), w is the field width, and s is the number of significant digits displayed.

===Decimal Format Phrase===

Form: rqd<apll>F</apll>w.d

where r is an optional repetition factor, q is an optional qualifier (<apll>B</apll>, <apll>C</apll>, <apll>K</apll>, <apll>L</apll>, and <apll>Z</apll> are allowed), d is an optional decorator (<apll>M</apll>, <apll>N</apll>, <apll>O</apll>, <apll>P</apll>, <apll>Q</apll>, <apll>R</apll>, and <apll>S</apll> are allowed), w is the field width, and d is the number of decimal digits displayed.

===Picture Format Phrase===

Form: rqd<apll>G</apll><text>

where r is an optional repetition factor, q is an optional qualifier (<apll>B</apll> and <apll>K</apll> are allowed), d is an optional decorator (<apll>M</apll>, <apll>O</apll>, <apll>P</apll>, <apll>R</apll>, and <apll>S</apll> are allowed), and text is the pattern for the picture format.

===Integer Format Phrase===

Form: rqd<apll>I</apll>w

where r is an optional repetition factor, q is an optional qualifier (<apll>B</apll>, <apll>C</apll>, <apll>K</apll>, <apll>L</apll>, and <apll>Z</apll> are allowed), d is an optional decorator (<apll>M</apll>, <apll>N</apll>, <apll>O</apll>, <apll>P</apll>, <apll>Q</apll>, <apll>R</apll>, and <apll>S</apll> are allowed), and w is the field width.

===Rational Format Phrase===

Form: rqd<apll>R</apll>w.d

where r is an optional repetition factor, q is an optional qualifier (<apll>B</apll>, <apll>C</apll>, <apll>K</apll>, <apll>L</apll>, and <apll>Z</apll> are allowed), d is an optional decorator (<apll>M</apll>, <apll>N</apll>, <apll>O</apll>, <apll>P</apll>, <apll>Q</apll>, <apll>R</apll>, and <apll>S</apll> are allowed), w is the field width, and d is the number of digits displayed in the denominator.

===Absolute Positioning Phrase===

Form: <apll>T</apll> or <apll>T</apll>p

where p is the absolute (origin-1) position in the line. If p is zero or is omitted, the next character is inserted at the rightmost position of the line.

===Relative Positioning Phrase===

Form: r<apll>X</apll>w

where r is an optional repetition factor, w is the (signed) field width, that is the number of spaces to move to the left (w < 0) or right (w > 0).

===Symbol Substitution===

All but the Positioning Phrases allow alternate symbols to be used in place of certain standard symbols. For example, the thousands separator used by the <apll>C</apll> qualifier may be substituted with a dot using <apll>S<,.></apll>, the decimal point used in numeric format phrases may be substituted with a comma using <apll>S<.,></apll>, and both may be substituted at the same time using <apll>S<,..,></apll> or <apll>S<.,,.></apll>.

In general, the text portion of Symbol Substitution consists of pairs of characters. The first character in each pair consists of a standard symbol which identifies the substitution class and is its default value. The second character in each pair is the (new) symbol to be used when the corresponding standard symbol is called for. Each standard symbol may appear as the first character in a pair at most once in each <apll>S</apll> Decorator. The order of the pairs is unimportant.

The list of substitution classes along with their (standard symbols) and the Format Phrases/Qualifiers in which they are allowed is as follows:

<table border="1" cellpadding="5" cellspacing="0" rules = "none" summary="">
<tr>
<td>Overflow (<apll>*</apll>)</td>
<td>Format Phrases: <apll>A</apll>, <apll>E</apll>, <apll>F</apll>, <apll>G</apll>, and <apll>I</apll></td>
</tr>
<tr>
<td>Decimal Separator (<apll>.</apll>)</td>
<td>Format Phrases: <apll>E</apll>, <apll>F</apll>, and <apll>I</apll></td>
</tr>
<tr>
<td>Thousands Separator (<apll>,</apll>)</td>
<td>Qualifier: <apll>C</apll></td>
</tr>
<tr>
<td>Exponent Separator (<apll>E</apll>)</td>
<td>Format Phrase: <apll>E</apll></td>
</tr>
<tr>
<td>Zero Fill (<apll>0</apll>)</td>
<td>Qualifier: <apll>Z</apll></td>
</tr>
<tr>
<td>Precision Loss Fill (<apll>_</apll>)</td>
<td>Format Phrases: <apll>E</apll>, <apll>F</apll>, and <apll>I</apll></td>
</tr>
<tr>
<td>Z Character (<apll>Z</apll>)</td>
<td>Format Phrase: <apll>G</apll></td>
</tr>
<tr>
<td>9 Character (<apll>9</apll>)</td>
<td>Format Phrase: <apll>G</apll></td>
</tr>
<tr>
<td>Rational Separator (<apll>r</apll>)</td>
<td>Format Phrase: <apll>R</apll></td>
</tr>
</table>
 

===Specific Value Substitution===

The <apll>O</apll> decorator may be used to substitute arbitrary text for any given value. Originally, it was designed as a generalization of the <apll>B</apll> Qualifier to allow arbitrary text to appear in place of a zero, as in <apll>O<Zilch>I8</apll>. Later, it was generalized even farther to substitute values other than zero, as in <apll>O2<Twice>I6</apll> or <apll>O3.141592653589793<π>F10.2</apll>.

The comparison of incoming data with the specific values is done using Comparison Tolerance.

Unlike all other Decorators, this one may appear multiple times within a single Format Phrase.

{{SFDM|FMT}}
{{Article footer|0|NO}}

Template:SFM

2019-10-13T22:17:33Z

Paul Robinson:

Note: <big>'''{quad}{{{1}}}'''</big> is a ''[[monadic]]'' form system function, you cannot assign a value to it.
{{System Variables}}<hr/>
{{Article footer|0|NO}}<includeonly>
[[Category:Monadic operators]]</includeonly><noinclude>
{{SF/doc}}
[[Category:Navigation]]

</noinclude>

Template:SFDM

2019-10-13T22:15:03Z

Paul Robinson: explain & add cat

Note: <big>⎕{{{1}}}</big> is available as both a ''[[monadic]]'' and ''[[dyadic]]'' form system function, you cannot assign a value to it.
{{System Variables}}
{{Article footer|0|NO}}<includeonly>[[Category:Dyadic operators]] [[Category:Monadic operators]]</includeonly>
<noinclude>
{{SF/doc}}
[[Category:Navigation]]
</noinclude>

Template:SFD

2019-10-13T22:10:37Z

Paul Robinson: explain & add cat

Note: {quad}{{{1}}} is a ''[[dyadic]]'' form system function, you cannot assign a value to it.
{{System Variables}}<hr/>
{{Article footer|0|NO}}<includeonly>[[Category:Dyadic p[erators]]</includeonly><noinclude>
{{SF/doc}}
[[Category:Navigation]]

</noinclude>

Template:System Variables

2019-10-13T22:05:05Z

Paul Robinson: t/c

{| class="wikitable" style="font-size: 95%;" width="{{{Width|{{{width|80%}}}}}}" align="center"
|-
! colspan="10" |[[System Variables]] (A value may be assigned to these except for <apll>⎕DM</apll>)
|-
{{SSV|ALX }}
{{SSV|CT }}
{{SSV|DM }}
{{SSV|DT }}
{{SSV|ELX }}
{{SSV|FC }}
{{SSV|FEATURE}}
{{SSV|FPC}}
{{SSV|IC }}
{{SSV|IO }}
|-
{{SSV|LR }}
{{SSV|LX }}
{{SSV|PP }}
{{SSV|PR }}
{{SSV|PW }}
{{SSV|RL }}
{{SSV|SA }}
{{SSV|WSID}}
|-
! colspan="10" | [[Niladic]] [[System Functions]] (a value cannot be assigned to these)
|-
{{SSF|A }}
{{SSF|AV }}
{{SSF|EM }}
{{SSF|ET }}
{{SSF|LC }}
{{SSF|NNAMES}}
{{SSF|NNUMS }}
{{SSF|SI }}
{{SSF|SYSID }}
{{SSF|SYSVER}}
|-
{{SSF|T}}
{{SSF|TC }}
{{SSF|TCBEL }}
{{SSF|TCBS }}
{{SSF|TCESC }}
{{SSF|TCFF }}
{{SSF|TCHT }}
{{SSF|TCLF }}
{{SSF|TCNL }}
{{SSF|TCNUL }}
|-
{{SSF|TS }}
{{SSF|WA }}
|-
! colspan="10" | [[Monadic]] or [[dyadic]] system functions (a value cannot be assigned to these)
|-
{{SSF|AT | Attributes}}
{{SSF|CR | Canonical representation}}
{{SSF|DC | Data Conversion}}
{{SSF|DFT | Discrete Fourier Transform}}
{{SSF|DL | Delay}}
{{SSF|DR | Data representation}}
{{SSF|EA | Execute alternate}}
{{SSF|EC | Execute controlled}}
{{SSF|ERROR | Signal error}}
{{SSF|ES | Event simulate}}
|-
{{SSF|EX | Expunge names}}
{{SSF|FMT | Format}}
{{SSF|FX | Function fix}}
{{SSF|MF | Monitor function}}
{{SSF|NAPPEND | Append data to an open native file}}
{{SSF|NC | Name classification}}
{{SSF|NCREATE | Create and open a native file}}
{{SSF|NERASE | Erase an open native file}}
{{SSF|NINFO | Native file information}}
{{SSF|NL | Name list}}
|-
{{SSF|NLOCK | Lock/unlock an open native file}}
{{SSF|NREAD | Read data from an open native file}}
{{SSF|NRENAME | Rename an open native file}}
{{SSF|NREPLACE| Replace data in an open native file}}
{{SSF|NRESIZE | Resize an open native file}}
{{SSF|NSIZE | Get the size of an open native file}}
{{SSF|NTIE | Open a native file}}
{{SSF|NUNTIE | Close a native file}}
{{SSF|STOP | Stop execution of a user-defined function/operator or Magic Function}}
{{SSF|TF | Transfer form}}
|-
{{SSF|TRACE | Trace execution of a user-defined function/operator or Magic Function}}
{{SSF|UCS | Universal character set}}
{{SSF|VR | Vector representation of a function}}
|-
! colspan="10" |Note that quad functions and variables (except for the <apll>⎕A</apll> family of functions) are case insensitive
|}<noinclude>
[[Category:Navigation]]
</noinclude>

Template:SF/doc

2019-10-13T21:58:20Z

Paul Robinson: t/c

The following message is not shown when this template is used, only when viewed directly.

This template is used for System Functions that are used thus the name. It is placed at the bottom of appropriate pages.

'''Available System Function templates:'''
* [[Template:SFD|<nowiki>{{SFD}}</nowiki>]]: Dyadic only
* [[Template:SFDM|<nowiki>{{SFDM}}</nowiki>]]: ''Both'' Dyadic and Monadic
* [[Template:SFM|<nowiki>{{SFM}}</nowiki>]]: Monadic only
* [[Template:SFN|<nowiki>{{SFN}}</nowiki>]]: Niladic only

<noinclude>[[Category:Navigation assistance]]</noinclude>

Template:SFN

2019-10-13T21:55:50Z

Paul Robinson: t/c

Note: <apll>⎕</apll>{{{1}}} is a ''[[niladic]]'' form system function, you cannot assign a value to it. 
{{System Variables}}<hr/>
{{Article footer|0|NO}}<noinclude>
{{SF/doc}}
[[Category:Navigation]]

</noinclude>

Template:SFN

2019-10-13T21:53:13Z

Paul Robinson: t/c

Template:SFN

2019-10-13T21:52:41Z

Paul Robinson: t/c

Note: <apll>⎕</apll>{{{1}}} is a ''[[niladic]]'' form system function, you cannot assign a value to it. 
{{System Variables}}<hr/>
{{Article footer|0|NO}<noinclude>
[[Category:Navigation]]

</noinclude>

Template:SSF

2019-10-13T21:48:58Z

Paul Robinson: explain & add cat

<includeonly>
|| [[System Function {{{1}}}|<apll>⎕</apll>{{{1}}}]]</includeonly><noinclude>
{{SF/doc}}
[[Category:Navigation assistance]]

This template is not intemded to be viewed directly. It is used to assist in building table rows.
</noinclude>

Template:SF

2019-10-13T21:45:28Z

Paul Robinson:

<includeonly>
|-
|| [[System Function {{{1}}}|⎕{{{1}}}]]
|| {{{2}}}</includeonly><noinclude>
{{SF/doc}}
[[Category:Navigation assistance]]

This template is not intemded to be viewed directly. It is used to assist in building table rows.
</noinclude>

Template:SF

2019-10-13T21:43:16Z

Paul Robinson: t/c

Template:SFM

2019-10-13T21:38:07Z

Paul Robinson:

Note: <big>'''{quad}{{{1}}}'''</big> is a ''[[monadic]]'' form system function, you cannot assign a value to it.
{{System Variables}}<hr/>
{{Article footer|0|NO}}<noinclude>
{{SF/doc}}
[[Category:Navigation]]

</noinclude>

Template:SFD

2019-10-13T21:36:33Z

Paul Robinson:

Note: {quad}{{{1}}} is a ''[[dyadic]]'' form system function, you cannot assign a value to it.
{{System Variables}}<hr/>
{{Article footer|0|NO}}<noinclude>
{{SF/doc}}
[[Category:Navigation]]

</noinclude>

Template:SF/doc

2019-10-13T21:35:31Z

Paul Robinson: t/c

The following message is not shown when this template is used, only when viewed directly.

This template is used for System Functions that are used thus the name. It is placed at the bottom of appropriate pages.

'''Available System Function templates:'''
* [[Template:SFD|<nowiki>{{SFD}}</nowiki>]]: Dyadic only
* [[Template:SFDM|<nowiki>{{SFDM}}</nowiki>]]: ''Both'' Dyadic and Monadic
* [[Template:SFM|<nowiki>{{SFM}}</nowiki>]]: Monadic only

<noinclude>[[Category:Navigation assistance]]</noinclude>

Template:SF/doc

2019-10-13T21:33:39Z

Paul Robinson: new template

The following message is not shown when this template is used, only when viewed directly.

This template is used for System Functions that are used thus the name. It is placed at the bottom of appropriate pages.

'''Available System Function templates:'''
* [[Template:SFD|<nowiki>{{SFD}}</nowiki>]]: Dyadic only
* [[Template:SFD|<nowiki>{{SFDM}}</nowiki>]]: ''Both'' Dyadic and Monadic
* [[Template:SFM|<nowiki>{{SFM}}</nowiki>]]: Monadic only

<noinclude>[[Category:Navigation assistance]]</noinclude>

Template:SFDM

2019-10-13T21:31:24Z

Paul Robinson: t/c

Note: <big>⎕{{{1}}}</big> is available as both a ''[[monadic]]'' and ''[[dyadic]]'' form system function, you cannot assign a value to it.
{{System Variables}}<noinclude>
{{SF/doc}}
[[Category:Navigation]]

</noinclude>

Creating New System Functions

2019-10-13T21:24:27Z

Paul Robinson: /* General Reference Notes */

Category:Features

2019-10-13T21:21:37Z

Paul Robinson: new

Features of APL as provided by NARS 2000.

Consistent Extensions in NARS2000

2019-10-13T21:20:13Z

Paul Robinson: /* Session Manager */

The following features are considered consistent extensions to the Extended APL Standard in that they replace error-producing behavior with non-error-producing behavior. Note that Extended APL Standard wants you to know that the use of a consistent extension prevents a program from conforming with the Standard.

== Language Features ==
* [[Sink]]: monadic left arrow (<apll>←R</apll>) suppresses the display of <apll>R</apll>.
* [[Indexing|Unified index reference, assignment, and modify assignment]] (<apll>R[L]</apll>, <apll>R[L]←A</apll>, and <apll>R[L]f←A</apll>): these three forms all allow both Reach and Scatter indexing — that is,
** if <apll>L⊃R</apll> is valid, it is equivalent to <apll>⊃R[⊂L]</apll>, and
** if <apll>L⊃¨⊂R</apll> is valid, it is equivalent to <apll>R[L]</apll>, and
** if <apll>L⌷R</apll> is valid, it is equivalent to <apll>R[⊃∘.,/L]</apll>, and
** if <apll>L⌷¨⊂R</apll> is valid, it is equivalent to <apll>⊂¨R[⊂¨L]</apll>
:Reach and Scatter indexing may appear together within a single instance of <apll>R[L]</apll>, <apll>R[L]←A</apll>, and <apll>R[L]f←A</apll>.
* [[Rank|Dyadic operator dieresis-jot]] (<apll>f⍤[X] Y</apll>) (rank) is used to apply a function to (monadic) or between (dyadic) cells of the argument(s).
* [[Compose|Dyadic operator jot]] (<apll>f∘g</apll>) (compose) is used to join two functions or a function and a variable to produce a derived function (e.g., <apll>,∘⍋∘⍋∘,</apll>) which is applied as a single function. For example, the function <apll>*∘2</apll> when applied monadically, squares its argument.
* [[Null|Monadic operator null]] (<apll>f⊙</apll>): To aid in resolving ambiguities with slash/slope as function/operator, use this operator. It passes through all functions as functions, and forces the symbols slash/slope to be functions rather than operators. For example, use <apll>(/⊙)/3 4</apll> instead of <apll>(/)/3 4</apll>.
* [[Partitioned_Enclose|Partitioned Enclose]] (<apll>L⊂[X] R</apll>): Partition <apll>R</apll> along the <apll>X</apll> axis according to <apll>L</apll>.
* [[Index_Generator|Monadic iota]] (<apll>⍳R</apll>) extended to negative indices. For example, in origin-0, <apll>⍳¯3</apll> returns <apll>¯3 ¯2 ¯1</apll>.
* [[Index_Generator|Monadic iota]] (<apll>⍳R</apll>) extended to length > 1 vector right arguments returns an array of indices whose shape is that of the right argument.
* [[Index_Of|Dyadic iota]] (<apll>L⍳R</apll>) extended to rank > 1 left arguments returns an array of vector indices to the left argument.
* [[Indexing|Index reference, assignment, modify assignment, squad, transpose, pick, and the axis operator]] (<apll>R[L]</apll>, <apll>R[L]←A</apll>, <apll>R[L]f←A</apll>, <apll>L⌷R</apll>, <apll>L⍉R</apll>, <apll>L⊃R</apll>, and <apll>f[L]</apll>) are each extended to negative values in <apll>L</apll>. That is, if the largest allowed value is <apll>N</apll>, then the allowable range for the values in <apll>L</apll> is <apll>1 ¯1[1]-N</apll> to <apll>N</apll>, inclusive. For example, <apll>A</apll>, <apll>A[⍳⍴A]</apll>, and <apll>A[⍳-⍴A]</apll> are all identical for any array <apll>A</apll> in either origin, as are <apll>A</apll>, <apll>(⍳⍴⍴A)⍉A</apll>, and <apll>(⍳-⍴⍴A)⍉A</apll>.
* [[Matrix_Inverse/Divide|Monadic and dyadic domino]] (<apll>⌹R</apll> and <apll>L⌹R</apll>) — matrix inverse/divide extended to use Moore-Penrose pseudo-inverse algorithm via Singular Value Decomposition.
* Prototypes for all primitive functions and operators.
* Jot may be used as either operand to a user-defined operator in which case the name associated with the jot inside the operator is undefined, that is, <apll>⎕NC</apll> on the name returns <apll>0</apll>.
* Generalized Identity Functions for reduction and inner product.
* [[Scalar_System_Variables|Out of range numeric assignments]] to one of these system variables (<apll>⎕CT</apll>, <apll>⎕DT</apll>, <apll>⎕FPC</apll>, <apll>⎕IC</apll>, <apll>⎕IO</apll>, <apll>⎕PP</apll>, <apll>⎕PW</apll>, or <apll>⎕RL</apll>) is set to the value in the allowable range nearest the ceiling of the given number. For example, if <apll>⎕FPC</apll> is set to <apll>23.7</apll>, that value is rounded up to <apll>53</apll>, the smallest value that system variable may assume.
* [[Scalar_System_Variables|Assigning a simple empty vector]] to one of these system variables (<apll>⎕CT</apll>, <apll>⎕DT</apll>, <apll>⎕FPC</apll>, <apll>⎕IC</apll>, <apll>⎕IO</apll>, <apll>⎕PP</apll>, <apll>⎕PW</apll>, or <apll>⎕RL</apll>) assigns the system default value to the variable.
* [[Find]]: dyadic epsilon underbar (<apll>L⍷R</apll>) using the Knuth-Morris-Pratt string searching algorithm.
* [[Reshape]]: (<apll>L⍴R</apll>) is extended to allow a non-empty Reshape of an empty in which case the right argument fill element is used, e.g., <apll>2 3⍴⍬</apll>.
* [[Mismatch]]: Primitive dyadic not equal underbar (<apll>L≢R</apll>) equivalent to <apll>~L≡R</apll>.
* [[Tally]]: Primitive monadic not equal underbar (<apll>≢R</apll>) which is equivalent to <apll>⍬⍴(⍴R),1</apll>.
* [[Indices]]: Primitive monadic iota underbar (<apll>⍸R</apll>) which is equivalent to <apll>(,R)/,⍳⍴1/R</apll>.
* [[Array Lookup]]: Primitive dyadic iota underbar (<apll>L⍸R</apll>) which for matrices looks up the rows of <apll>R</apll> in the rows of <apll>L</apll>. In general, this function looks up the trailing subarrays of <apll>R</apll> in the vector of trailing subarrays of <apll>L</apll>, and is equivalent to <apll>(⊂⍤¯1 L)⍳⊂⍤(¯1+⍴⍴L) R</apll>.
* [[Type]]: Primitive monadic function down tack (<apll>⊤R</apll>) (Type).
* [[Composition]]: Primitive dyadic operator dieresis circle (<apll>L f⍥g R</apll>) (Composition).
* [[Root]]: Primitive monadic and dyadic functions (<apll>√R</apll> and <apll>L√R</apll>) (Root).
* [[Sets]]: Primitive dyadic functions (<apll>L§R</apll>, <apll>L⊆R</apll>, and <apll>L⊇R</apll>) (Set functions).
* [[Primes]]: Primitive monadic and dyadic functions pi (<apll>πR</apll> and <apll>LπR</apll>) (Prime decomposition and Number-theoretic functions).
* [[Sequence]]: Primitive dyadic function (<apll>L..R</apll>) (Sequence).
* [[Variant]]: Primitive dyadic operator quad colon (<apll>f⍠V R</apll> and <apll>L f⍠V R</apll>) (Variant).
* [[Anonymous Functions/Operators/Hyperators]]: one-line grouping of one or more statements all enclosed in braces such as <apll>{(+⌿⍵)÷≢⍵}</apll>.
* [[Determinant]]: Primitive dyadic operator (<apll>f.g R</apll>) (Determinant Operator).
* [[Convolution]]: Primitive dyadic operator (<apll>L f⍡g R</apll>) (Convolution Operator).

* New System Variables
** <apll>⎕DT</apll> ([[System_Variable_DT|Distribution Type]])
** <apll>⎕FC</apll> ([[System_Variable_FC|Format Control]])
** <apll>⎕FPC</apll> ([[System_Variable_FPC|Floating Point Control]])
** <apll>⎕IC</apll> ([[System_Variable_IC|Indeterminate Control]])
* New or Changed System Functions
** <apll>⎕A</apll> ([[System_Function_A|Uppercase English Alphabet]]) — returns the 26-character uppercase English alphabet.
** <apll>⎕AT</apll> ([[System_Function_AT|Object Attributes]]) — returns various attributes (Valence, Fix Time, Execution Properties, and Size) of an object
** <apll>⎕AV</apll> ([[System_Function_AV|Atomic Vector]]) — has all UCS-2 Unicode characters (65,536 in length)
** <apll>L ⎕CR R</apll> ([[System_Function_CR|Canonical Representation]]) — <apll>L=1</apll> (nested vector of character vectors) and <apll>L=2</apll> (character matrix)
** <apll>⎕DM</apll> ([[System_Function_DM|Diagnostic Message]])
** <apll>⎕DR R</apll> and <apll>L ⎕DR R</apll> ([[System_Function_DR|Data Representation]])
** <apll>L ⎕EA R</apll> ([[System_Function_EA|Execute Alternate]])
** <apll>⎕EC R</apll> ([[System_Function_EC|Execute Controlled]])
** <apll>⎕EM</apll> ([[System_Function_EM|Event Message]])
** <apll>⎕ERROR R</apll> ([[System_Function_ERROR|Signal Error]])
** <apll>⎕ES R</apll> and <apll>L ⎕ES R</apll> ([[System_Function_ES|Event Simulate]])
** <apll>⎕ET</apll> ([[System_Function_ET|Event Type]])
** <apll>⎕FMT R</apll> ([[System Function FMT#Monadic_Function|Format arrays within Boxes]])
** <apll>L ⎕FMT R</apll> ([[System Function FMT#Dyadic_Function|Format arrays using Format Phrases]])
** <apll>⎕MF R</apll> ([[System_Function_MF|Monitor Function]])
** <apll>⎕Nxxxx</apll> ([[System_Function_Native_Files|Native File Functions]])
** <apll>⎕NC R</apll> ([[System_Function_NC|Name Class]]) — returns <apll>21</apll> through <apll>24</apll> for System labels, (Unused), Magic functions, and Magic operators.
** <apll>⎕NL R</apll> ([[System_Function_NL|Name List]]) — <apll>R=21</apll> through <apll>24</apll> lists System labels, (Unused), Magic functions, and Magic operators.
** <apll>⎕STOP</apll> ([[System_Function_STOP|Query/Set STOP Property On Functions]])
** <apll>⎕SYSID</apll> ([[System_Function_SYSID|System Identification]])
** <apll>⎕SYSVER</apll> ([[System_Function_SYSVER|System Version]])
** <apll>⎕TC</apll> and other related <apll>⎕TC</apll>''xxx'' ([[System_Function_TC|Terminal Control]])
** <apll>L ⎕TF R</apll> ([[System_Function_TF|Transfer Form]]) — <apll>1=|L</apll> (Type 1 Transfer Form) and <apll>2=|L</apll> (Type 2 Transfer Form); <apll>L<0</apll> interprets <apll>R</apll> and the result as Unicode characters; <apll>L>0</apll> interprets them as APL2 characters
** <apll>⎕TRACE</apll> ([[System_Function_TRACE|Query/Set TRACE Property On Functions]])
** <apll>⎕UCS R</apll> ([[System_Function_UCS|Unicode Character Set]])
** <apll>⎕VR R</apll> ([[System Function VR|Visual Representation]])
** <apll>⎕WA</apll> ([[System Function WA|Workspace Available]])
* New Datatypes
** 2-byte Characters (Unicode, that is, UCS-2)
** 64-bit Integers
** APAs (Arithmetic Progression Arrays) (e.g., <apll>2 3 4⍴⍳24</apll> and <apll>1E12⍴1</apll>)
** ± Infinity (e.g., <apll>∞</apll> for infinity and <apll>¯∞</apll> for negative infinity) — considerable development work needs to be done to this feature to handle the many special cases
** Rational numbers (e.g., <apll>1r3</apll> and <apll>12345x</apll>)
** Variable precision floating point numbers (e.g., <apll>1.234v</apll> and <apll>12v</apll>)

== Miscellaneous Syntax ==
* [[Strand_Assignment|Strand Assignment]]: A sequence of names enclosed in parentheses can be assigned to. For example, <apll>(A B)←1 2</apll> is the same as <apll>A←1</apll> followed by <apll>B←2</apll>.
* [[Modified_Assignment|Modified Assignment]]: An arbitrary (primitive or user-defined) dyadic function may appear immediately to the left of an assignment arrow. For example, <apll>Af←1</apll> is the same as <apll>A←Af¨ 1</apll>, and <apll>A[L]f←1</apll> is the same as <apll>A[L]←A[L]f¨ 1</apll>.
* [[Modify_Strand_Assignment|Modify Strand Assignment]]: An arbitrary (primitive or user-defined) dyadic function may appear immediately to the left of the assignment arrow used in Strand Assignment (e.g. <apll>(A B)f←1 2</apll> is the same as <apll>A←Af 1</apll> followed by <apll>B←Bf 2</apll>).
* [[Function/Operator/Hyperator_Assignment|Function/operator/hyperator assignment]]: A primitive function, operator, or derived function may be assigned to any available name (e.g., <apll>F←⍋</apll>, or <apll>F←¨</apll>, or <apll>F←∘</apll>, or <apll>F←+.×</apll>).
* [[Axis|Axis operator with primitive scalar dyadic functions]]: The axis operator indicates how the coordinates of the lower rank argument map to the coordinates of the higher rank argument. For example, <apll>(1 2+[1] 2 3⍴R</apll> is equivalent to <apll>(⍉3 2⍴1 2)+2 3⍴R</apll>.
* [[Axis|Axis operator with primitive scalar dyadic functions]]: The order of the values in the axis operator brackets is significant. For example, <apll>(2 3⍴L)+[1 2] 2 3 4⍴R</apll> and <apll>(⍉2 3⍴L)+[2 1] 2 3 4⍴R</apll> are identical.
* [[Axis|Axis operator with the dyadic derived function from the Each operator]]: As with primitive scalar dyadic functions, the axis operator indicates how the coordinates of the lower rank argument map to the coordinates of the higher rank argument. For example, <apll>(2 3⍴L)⍴¨[1 2] 2 3 4⍴R</apll> is equivalent to <apll>(3 1 2⍉4⌿1 2 3⍴L)⍴¨2 3 4⍴R</apll>.
* [[Axis|Axis operator to Ravel]]: The order of the values in the axis operator brackets is significant, and may transpose coordinates in the right argument before mapping the values to the result. For example, <apll>,[2 1] R</apll> and <apll>,[1 2] R</apll> are both valid and have the same shape and values but, in general, the values are in a different order.
* [[Axis|Axis operator with user-defined functions/operators/hyperators]]: A user-defined function/operator/hyperator may be sensitive to the axis operator in the same way various primitive functions and operators are. For example, <apll>FOO[2 3] R</apll> is valid if the function header is defined as <apll>∇ Z←FOO[X] R</apll>.
* [[Axis|Axis operator values may be negative]]: That is, if the largest allowed value is <apll>N</apll>, then the allowable range for axis operator values is <apll>1 ¯1[1]-N</apll> to <apll>N</apll>, inclusive.
* [[User-Defined_Functions/Operators/Hyperators|Strand left and right arguments and result to user-defined functions/operators]] along with optional left argument may be specified: For example, a strand right argument may be specified as <apll>∇ Z←FOO (R1 R2 R3 R4)</apll> or, more fully, with a non-displayable result and strands used in all of the result, left, and right arguments with an optional left argument may be specified as <apll>∇ (Z1 Z2)←{L1 L2 L3} (LO OP2[X] RO) (R1 R2 R3 R4)</apll>.
* Note that braces are '''required''' to surround the left argument of an ambivalent function as in <apll>∇ Z←{L} FOO R</apll>.
* [[User-Defined_Functions/Operators/Hyperators|The result of a user-defined function/operator/hyperator]] may be marked as non-displayable by enclosing it in braces, as in <apll>∇ {Z}←FOO R</apll>. If the result part of the header consists of multiple names, either <apll>∇ {Z1 Z2}←FOO R</apll> or <apll>∇ ({Z1 Z2})←FOO R</apll> or <apll>∇ {(Z1 Z2)}←FOO R</apll> may be used to mark the result as non-displayable.
* [[Control_Structures|Control structures]] on one line or split across multiple lines (e.g., <apll>:for I :in ⍳N ⋄ ... ⋄ :endfor</apll>).
* [[Point_Notation|Point Notation]] (Base, Euler, Pi, and Gamma) are extensions to the familiar Decimal and Exponential Point Notation for entering numeric constants. For example, the numeric constant <apll>16bffff</apll> is a shorthand for calculating <apll>16⊥15 15 15 15</apll>.
* [[Trains]]: e.g., <apll>avg←(+⌿ ÷ ≢)</apll> applies the functions to its argument(s) in a particular way (in this case, to compute the average of a numeric vector).
* [[System Labels]]: <apll>⎕PRO</apll>, <apll>⎕ID</apll>, and <apll>⎕MS</apll> in user-defined functions/operators.

== System commands ==
* [[System Command CLOSE|<apll>)CLOSE</apll>]]
* [[System Command COPY|<apll>)COPY</apll>]]
* [[System Command EDIT|<apll>)EDIT</apll>]]
* [[System Command EXIT|<apll>)EXIT</apll>]]
* [[System Command IN|<apll>)IN</apll>]]
* [[System Command INASCII|<apll>)INASCII</apll>]]
* [[System Command NEWTAB|<apll>)NEWTAB</apll>]]
* [[System Command EXIT|<apll>)OFF</apll>]]
* [[System Command OUT|<apll>)OUT</apll>]]
* [[System Command RESET|<apll>)RESET</apll>]]
* [[System Command ULIB|<apll>)ULIB</apll>]]

== Session Manager ==
* [[Function_Editing|Function editor]]: this feature may be invoked by typing <apll>∇</apll> by itself, or <apll>∇</apll> followed by a name, or <apll>)EDIT</apll> by itself, or <apll>)EDIT</apll> followed by a name, or by double-right-clicking on a function name in the session manager or function editor windows
* [[Session_Manager|Multiple workspaces]] may be open at the same time and switched between via Tabs
* [[Initialization_and_Workspace_Files#Workspace_Files|Workspaces]] are saved as plain text ASCII files
* All variable names are two-byte characters (Unicode, that is, UCS-2)
* Array rank and dimension limit of 64 bits
* [[Session_Manager|Multilevel Undo]] in function editing
* Undo buffer saved with function for reuse on next edit

[[Category:Features]]

C Source Code Conventions and Abbreviations Dictionary

2019-10-13T21:17:39Z

Paul Robinson: t/c

'''<big>NARS C Source Code Conventions and Abbreviations Dictionary:</big>'''

==Conventions==

{| class="wikitable" style="width: 50%"
! Convention
! Syntax
! Description/Where Used
! Sample Use
! Purpose
|-
| '''PrimFn'''
| Prefix
| name prefix to all Primary APL functions
| '''PrimFn'''Rho_EM_YY
| Quickly identify such names
|-
| '''SysFn'''
| Prefix
| name prefix to all Quad type System Functions
| '''SysFn'''WA_EM_YY
| Quickly identify such names
|-
| '''_EM_YY'''
| Suffix
| name suffix to all Primary APL functions AND Quad System Functions, including monadic and dyadic calls
| SysFnTS'''_EM_YY'''
| Quickly identify such names, referencing
|-
|}

==Abbreviations Dictionary==

{| class="wikitable" style="width: 70%"
! Abbrev
! Meaning
! Definition Location, Purpose, Cross Ref's
! Sample Source Code Usage
|-
| '''APA'''
| Arithmetic Progression Array
| C code suffix to variable type, sometimes variable names. for example, ⍳6 or iota-6 is an '''arithmetic progression array''' of integers. Definition for ARRAY_'''APA''' found in file <datatype.h>
| ARRAY_'''APA''' is a variable type. Ref. wiki '''[[APA|documentation page APA]]'''. For closely examining '''APA ''' datatypes, see also '''[[System_Function_DR|System Function ⎕DR]]'''.
|-
| '''lp'''
| long pointer
| Usually found as a prefix to variable names. NARS makes frequent use of pointers to speed up processing times, to make NARS2000.exe more efficient.
| '''lp'''tkRhtArg (var name; long ptr to token var structure of a right hand argument for a function call)
|-
| '''NELM'''
| Number of Elements
| Usually embedded within variable names. Conceptually like '''[[Rho|Rho or <apll>{rho}</apll>]]''' of a vector.
| APL'''NELM''' apl'''NELM'''Rht; // VarType VarName; Right arg NELM for variable type(APLNELM) and variable named aplNELMRht
|-
| '''ODS'''
| OutputDebugString
| Variously used throughout program, especially see file <debug.c> for string printing to console, debugging. See function int oprintfW, usage example per <updates.c>, oprintfW (L"%3d: SetEvent on %p (IDC_DNLPAUSE_BN -- hSuspend)\n", guCnt++, dnlThrStr.hSuspend); % means "Prt var here"; 3 = "use at least 3 spaces(max width) to show, pad as needed"; d = "Var is int"; hex-%x; float-%f; str-%s; ptrs-%p. L prefix=unicode str
| int oprintfW(LPWCHAR lpwszFmt, ...) // Ptr to format string, variable list
|-
| '''PerTab'''
| per tab, esp. per APL workspace tab
| Embedded in var names. Detailed explanation of PerTab found in C source header file <pertab.h>. '''NARS supports multiple simultaneously open and running workspaces.''' Each workspace is displayed as a separate '''Tab''', much like folder tabs. All variables in all workspace are distinctly maintained, with each PerTab.
| LP'''PERTAB'''DATA lpMemPTD; where LP'''PERTAB'''DATA is the variable type and lpMemPTD is a pointer to PerTabData global memory
|-
| '''PTD'''
| per tab of data
| Embedded in var names. Each NARS workspace is kept separate and distinct in its own PTD.
| lpMem'''PTD''' structured var name, in this case a ptr to PerTabData global memory
|-
| '''Rank'''
| Rank
| Rank: Scalars=0, Vectors=1, Matrices=2..N. Like {rho}{rho} of an APL variable or contained data structure, see shape of the shape '''[[Rho|RhoRho or {rho}{rho}]]'''.
| APL'''RANK''' apl'''Rank'''Lft // Left arg rank (variable type, variable name)
|-
| '''SIS'''
| State Indicator Stack
| Frequently embedded within variable and function names. Detailed explanation of SIS found in C source header file <sis.h> See also APL's '''[[System_Command_SI|System Command )SI]]'''.
| lpMemPTD->lp'''SIS'''Cur->ResetFlag; (var name) AND Fill'''SIS'''Nxt (fcn name)
|-
| '''tk'''
| token
| Frequently found embedded in structured variable names. Tokens are [http://www.c4learn.com/c-programming/c-tokens-keywords-identifiers/ basic building blocks of C Programming]; hence '''tk''' vars frequently represent important structured variables in NARS.
| LPTOKEN lp'''tk'''RhtArg
|-
| '''TKT_'''
| token type
| Prefix to typed variable names. Most tokens are simple in that they have type and data only.e,g, TKT_LEFTPAREN and '('. Some frequently used tokens are complex in that their data points to other data. Token types are also associated with a Constant type '''value''', e.g. '''TKT_'''VARARRAY = '''1A'''(Hex val, 26 dec val). Token types may also represent APL/System Functions - '''TKT_'''FCNNAMED (52 hex) = a named function. Full explanation see file <tokens.h>. See also typedef structures '''[[Frequently_Used_TypeDef_Structures_and_Variables#TOKEN|TOKEN]]'''.
| '''TKT_'''VARARRAY - main workhorse token type. Its tkData is an HGLOBAL (global memory handle) which contains an array which is either simple, nested, or mixed(combination of diff data types, e.g. string int float and or double).
|-
| '''UTF'''
| Unicode Transformation Format
| Variable names, constants, [http://unicode.org/faq/utf_bom.html especially UTF16]; algorithmic mapping for Unicode code numbers (except surrogate code points) to unique byte sequencing (esp. 16-bit = 2-byte sequences). ASCII uses 2^7 bits=128 codes; EBSDIC 2^8=256 codes. Unicode 2-byte uses 2^16=65,536 codes, as currently does NARS, see also System Functions '''[[System_Function_AV|<apll>{quad}</apll>AV]]''' and '''[[System_Function_UCS|<apll>{quad}</apll>UCS]]'''. Both the 32-bit and 64-bit NARS2000.exe's use 16-bit uncodes; the 32 and 64 bit NARS exe's refer to numeric data computer representations and calculation precisions. List of defined '''UTF'''16_ vars see file <Unicode.h>.
| '''UTF'''16_RHO
|}

[[Category:NARS 2000]]

Category:NARS 2000

2019-10-13T21:15:09Z

Paul Robinson: new

These pages deal with the NARS 2000 system itself. How to install, update, program or implement NARS 2000. These pages should have npthing to do with the APL kanguage.

Building An Executable

2019-10-13T21:09:38Z

Paul Robinson: /* Periodic NARS Updates */

<div style="float:right; padding-left:5px;">
{| style="text-align:left; border:1px solid #aaaaaa; background-color:#f9f9f9;width: 200px;font-family: Verdana, sans-serif;"
|- padding:5px;padding-top:0.5em;font-size: 95%;
|
----
<div style="border:1px solid #ccc; background: #fff; border-right:3px solid #ccc; border-bottom:3px solid #ccc; text-align: center; padding:3px; float:right; font-size: smaller; line-height: 1.3; margin-right: 4px;">
<div style="width:100%">{{CURRENTDAYNAME}}</div>
<div style="font-size: x-large; width: 100%;">{{CURRENTDAY}}</div>
<div style="width: 100%;"> {{CURRENTMONTHNAME}}</div>
<div style="width: 100%;">{{CURRENTYEAR}}</div>
<div style="background: #aaa; color: #000;">'''{{CURRENTTIME}}''' UTC</div>
</div>
<big>'''NARS2000 Building The Executable'''</big>
----
<div style="text-align:center;">
</div>
|-
|
__TOC__
|}
</div>
==Update Notice==

Although it is not the "ONLY compiler - IDE (integrated developer's environment) choice", the below uses '''Visual Studio 2013''' as its designated C/C++ Compiler and IDE(Integrated Developer's Environment, GUI/Graphical User Interface for programming). All source code compiles correctly and multiple APL workspaces have been tested for correct APL/NARS functionality. This page is current, up-to-date re NARS working with VS2013's compiler and standards. The conversion to VS2013 resulted in a more up-to-date (5 years[2008 to 2013] more current software technology) program for the GUI Builder and Compiler interface, including newer C/C++ programming standards. This has represented a major cyclical software upgrade and results in greater APL user functionality via improved C coding. Recent releases of NARS2000.exe (32 and 64-bit versions) are fully functional.
<div align="right">v---- '''Useful Developer links:''' ----v [http://svnbook.red-bean.com Version Control with Subversioning - Conceptual Gen Bkgnd.] [http://sourceforge.net/p/forge/documentation/svn/ Source Forge Versioning Documentation] [http://sourceforge.net/p/nars2000/code/HEAD/tree/trunk/ Source Forge NARS2000 Source Code]</div>

==Why Build Your Own==

First of all, you do not have to build your own. NARS has already created a great existing Nested Arrays Research System APL interpreter. NARS2000.exe is freely available at [http://www.nars2000.org/download/Download.html NARS Downloads]. Downloads includes Beta releases for APLers so inclined.

On the other hand, why not expand your programming/software and computer skill horizons? Many people think and believe '''Kenneth Iverson's''' work remains that of a true genius, a bright light among some very bright intellectual lights, both from a theoretical as well as a software implementation perspective. Here's your opportunity to attempt to improve upon some very substantive, preexisting software development work - to further it, to make it even better, and perhaps best of all - '''it's free'''.

Personalize some already pretty amazing software for yourself, or share it with others and get '''their feedback''' for even greater insight and subsequent improvement. NARS version of APL already has over a quarter million lines of source code, subroutines, macros, functions, etc. - 50 years of sometimes intense and continuing evolution, so you are not creating something from undeveloped scratch, but inheriting and working from already highly evolved, rigidly disciplined concepts and rigorously debugged software over time.

'''APL/2''' has been used in physics, science, genetic engineering-DNA studies, advanced mathematics, robotics, engineering, artificial intelligence, image processing, bio-medicine, VLSI, financial, statistical and social science applications. NASA and Astronomers have used APL.

Now APL/2 is 100% customizable. Perhaps you will be the first to customize APL to safely drive a vehicle, help save a life, make new discoveries or make some process(es) more efficient.

It's '''free'''. It's '''evolved'''. Once you start examining NARS/APL/APL2 source code you'll find it is comprehensive, elegant, process-symbol-efficient, focused toward the end-user, evolved over some fifty years of use, structurally enigmatic, tirelessly debugged and rich with coding techniques - a great learning tool, even if absolutely nothing else - and NARS believes it is far, far better than just a learning tool. You'll learn about Bison Parsing, how it helps define compilers and interpreters. Further, NARS is a tremendous opportunity to learn more about the human-machine interface; how machine hardware operates and - better understand how software and hardware interact together.

One of the stellar, intellectually expansive aspects of APL/2 is - how fully the language embraces the breadth of hardware functionality. This includes instructions running core processor chip(s) and peripheral devices. This is not your grandparents' punch-card software program run on a room-sized computer, although that was marvelous at its time, but it may have taken him/her several days to get results back for in an introductory chemistry or math lab course. Today '''[http://phys.org/news/2015-03-quantum-unexpected-ways.html data structures influence speed of quantum search in unexpected ways]'''.

==Platforms==

The current version of NARS2000 may be run and built on a variety of Windows platforms, including most or all post-Windows-98 OS versions. Furthermore, a long-term goal is to enable NARS to be built on Linux, Mac OS, etc. as per user requests and Developer interests. If you do not have a Windows machine, the following may be helpful to you:

'''[http://www.howtogeek.com/187359/5-ways-to-run-windows-software-on-a-mac/ Five ways to run Windows software on a Mac.]''' From HowToGeek.com, methods include 1)Virtual Machines, 2)Boot Camp, 3)Wine, 4)CrossOver Mac (not free) and 5)Remote Desktop.

'''[http://www.howtogeek.com/133515/4-ways-to-run-windows-software-on-linux/ Four ways to run Windows software on Linux.]''' Again from HowToGeek.com, methods include 1)Use Wine, 2)Run Windows in a Virtual Machine, 3)Try Crossover (not free) and 4)Remote Desktop. A fifth way per [http://www.pcworld.com/article/2900497/how-to-run-windows-software-in-linux-everything-you-need-to-know.html PC World] is dual booting both Linux and Windows on your machine. This essentially involves partitioning hard drives with a portion reserved for Linux and a portion reserved for Windows. With costs of external hard drives continuing to decline, buying an external or network hard drive may free up hard drive storage space requirements.

'''[http://www.howtogeek.com/173353/how-to-run-windows-software-on-a-chromebook/ How to Run Windows Software on a Chromebook {notebook or tablet PC}.]''' Again from HowToGeek.com, methods include 1)Access a Windows Desktop Remotely, 2)Use Developer Mode and Install Wine (not available for all Chromebooks), 3)Use Developer Mode and Install a Virtual Machine (may require an Intel Chromebook).

Furthermore, if you work using a tablet or other computing device which supports remote desktop software such as '''[http://teamviewer.com Team Viewer]''' and you have a home or work computer running Windows - then you can remotely use NARS over your network and internet using that computer as a host and your local device as a client. Network and internet speeds are sufficiently fast and TeamViewer, for instance, is very good at making your remote desktop seem and respond as if virtually right in front of you.

For the present, the following sections detail descriptions for building the executable with bias towards Windows.

==Downloads==

To build the executable in summary you'll need the following:

# C Compiler and Linker
## Make program
## Resource Compiler
## Windows SDK
# Parser Generator
# Zip Utility
# PHP (Hypertext Preprocessor)
# NARS2000 Source Code
# NARS2000 External Libraries
# Optionally, Multi-precision Library Source
# STDINT.H header file
# Version Control program
# Doctor Dump SDK
# Optionally, a File Differencing/Merge program
 All of the tools you'll need are '''freely available'''. Some of them happen to be Microsoft-specific. Bill Gates while at Harvard actually worked a bit on/with APL, obviously he discovered the importance of working with arrays and symbolic notation. At the same time there is no reason more generic tools (such as [http://www.delorie.com/djgpp/ DJGPP], [http://www.cygwin.com/ Cygwin] or [http://www.mingw.org/ MinGW]) can't be used, a task NARS is hoping someone will volunteer to investigate. In particular, the '''tools currently used''' to create the APL Executable, in detail, are as follows:
 
# '''C''' (needed for this NARS2000 project is '''Visual C++ 2013''' = C++ GUI development environment and compiler for the C language, which much of APL's interpreter is written in). Compiler and Linker: '''[https://app.vssps.visualstudio.com/profile/review?download=true&family=VisualStudioExpressDesktop&release=VisualStudio2013Upd4&type=web&slcid=0x409 Microsoft Visual Studio 2013 Express for Desktop Windows]''' (download requires a FREE Microsoft/Visual Studio account) OS requires Windows XP or later — includes Link, Make, a Resource Compiler, and an SDK (among others). Download/Installation Notes: The '''downloaded file''' may be double-clicked in Windows Explorer. VS 2013 does NOT Install to a mapped or network drive(but to something like C:\Program Files\...). It must be Installed on a local PC drive (e.g. C:\...) and '''unmapped directory''' (but you can map to it later) - Microsoft apparently requires installation to a local machine drive letter such as "C:\...".   VS2013 Desktop is free '''and''' it includes a GUI or graphical user interface (icon-based IDE or integrated developer's environment), which is geometrically easier to use than a command-line interface. Windows 8.1 SDK (does NOT require Windows 8.1, but does update for some 8.1 capabilities, especially useful for using Visual Studio 2013; '''[https://msdn.microsoft.com/en-us/windows/desktop/bg162891.aspx?f=255&MSPPError=-2147217396 download is available at Microsoft]'''. '''Windows SDK''' (the following MAY NOT BE NECESSARY, SDK=Software Developers Kit, sometimes needed for '''64-bit installations''', usually choose download file GRMSDKX_EN_DVD.iso even for Intel machines) '''[http://www.microsoft.com/en-us/download/details.aspx?id=18950 download here]''', with '''installation instructions [https://github.com/enGits/engrid/wiki/Configure-Microsoft-Visual-Studio-2008-Express-to-also-build-for-Windows-x64 here]'''.
# '''Parser Generator''': '''[https://cygwin.com/install.html Bison]''', a Cygwin package, Save and run either '''setup-x86.exe''' (32-bit systems) or '''setup-x86_64.exe''' (64-bit systems) as appropriate to your system, '''Choose A Download Source''': Install from Internet, '''Select Root Install Directory''', '''Select Local Package Directory''', '''Select Your Internet Connection''', '''Choose A Download Site''', '''Select Packages''': Leave alone '''All (Default)''' - first time through, just click [Next], '''Devel''', and '''bison''', other dependent packages may be installed along with '''bison''', if not then '''after first''' Cygwin installation finishes, double-click the downloaded Cygwin file in Windows Explorer, downloaded filename should be something like '''setup-x86_64.exe''' and the '''second time through''' do specifically download and install '''Dev''', '''Bison''' - informally note the '''tree structure''' during the Bison download/install since '''creating parse trees''' is '''very much''' a ''Bison program specialty'', a strength. Compilers and even APL itself relies heavily on correct statement type recognition and parsing. To make sure you successfully downloaded and installed '''bison.exe''', the file should be '''found''' or reside in the C:\Cygwin\bin or C:\cygwin64\bin folder. Make note of the folder location since you will need it when setting the PARGEN environment variable shortly, below.
# '''Zip Utility''': '''[http://www.7-zip.org/ 7-Zip]''' (Latest version, 32- or 64-bit, as appropriate to your system; needed to Extract/Unzip the files and folders you are downloading for this project.) If you already have a Zip utility program on your PC, Tablet or Server such as WinZip, you can normally skip the 7-Zip download/install.
# '''PHP''' (Hypertext Preprocessor): '''[http://www.php.net/downloads.php Downloads]''' (Windows downloads for Windows systems.) (Windows binaries/VC9 x86 Thread Safe/Latest version/Zip or Installer, your choice) (Items to Install: Entire '''Script Executable''', and entire '''Extras'''). Place the unzipped file's contents into something like "C:\PHP". The executable file "php.exe" needs to be "on your directory or environmental path" when later compiling or building the APL executable.
# '''NARS2000 Source Code''': Click on '''[http://sourceforge.net/projects/nars2000/ Browse Code] button''' at '''NARS''' SourceForge.net '''code repository'''.
## You also likely need a Version Control program for SourceForge code 'checkouts', e.g. see '''Tortoise SVN''' below and '''[http://tortoisesvn.net/ here, visit Tortoise SVN's download page]''', then download and install Tortoise SVN's 64-bit or 32-bit version depending on your operating system to subsequently be able to auto-check-out NARS source code. '''Prior''' non-current NARS Source Code versions available at [http://code.google.com/p/nars2000/source/checkout Code Google].
# '''NARS2000 External Libraries''': [http://www.nars2000.org/download/binaries/misc.zip Miscellaneous Library] (misc.zip, which contains 4 .php files and 1 .ttf file - all directly unzipped into C:\NARS2000) and the following NARS libraries:
## [http://www.nars2000.org/download/binaries/mplibs.zip '''MPIR/MPFR/ECM Libraries'''] - These libraries(mplibs.zip) should be directly extracted or unzipped into the C:\NARS2000 folder such that three(3) distinct sub-directories are '''directly''' created: \ecm, \mpfr and \mpir, e.g. C:\NARS2000\ecm.
## [http://www.nars2000.org/download/binaries/gsldir.zip '''gsl Library'''] - This library(gsldir.zip) should be directly un-zipped into the C:\NARS2000 folder such that it becomes '''C:\NARS2000\gsl'''. Folder structure "C:\NARS2000\gsldir\gsl" would be invalid.
## [http://www.nars2000.org/download/binaries/qdebug.zip '''qdebug Library'''] - This library(qdebug.zip) should also be directly un-zipped into the C:\NARS2000 folder such that it becomes '''C:\NARS2000\qdebug'''. Make sure it is NOT double-enclosed when unzipped, for example the following would be an invalid folder setup structure: C:\NARS2000\qdebug\qdebug.
# '''Multi-precision Library Source Code: [http://www.nars2000.org/download/binaries/mpfns-src.zip MPIR/MPFR/ECM Source]'''. This zipped download is large (roughly 0.5GB) and is needed primarily to reproduce files in the MPIR/MPFR/ECM Library download so as to satisfy requirements of the GNU General Public License (GPL) v3. For more details on using the files in the download, look in the zipped file for <code>readme.txt</code>. If you are content to use the already-compiled existing binary libraries in [http://www.nars2000.org/download/binaries/mplibs.zip MPIR/MPFR/ECM Libraries], you may not immediately need the MPIR/MPFR/ECM Source Code; on the other hand - 128-bit CPU chips are in manufacturing production pipelines, quadruple-precision 128-bit floating-point format has been standardized by the IEEE and ultra-precise calculations are already needed in such fields as quantum physics, ref. [http://phys.org/news/2014-06-physicists-quantum-ultra-precise.html Physicists take quantum leap toward ultra-precise measurement], 6/2/2014. One of APL's strengths is its handling of mathematically precise calculations and the '''large size''' of the multi-precision source code library reinforces that.
# [http://msinttypes.googlecode.com/svn/trunk/stdint.h STDINT.H] header file installed in the MS Visual Studio 2013 include directory (V:\VC\include -- see below)
# '''SubVersion Control program''': [http://tortoisesvn.net/downloads Tortoise SVN] (Current version, 32- or 64-bit depending upon your OS)
# '''Doctor Dump SDK''': [https://drdump.com/public/DoctorDumpSDK/DoctorDumpSDK.zip Doctor Dump SDK] - e.g. DoctorDumpSDK.zip.
# '''File Differencing/Merge program''': [http://winmerge.org/ WinMerge] ('''Latest stable version''', usually downloads to something like WinMerge-k.m.n-Setup.exe where k, m and n are version/sub-version numbers.)

==Install Tools==

'''Preface''', Convention: '''x86''' generally refers to '''32-bit''' software installations while 64 (or blank) represents 64-bit software installations on a Windows OS machine. NARS works on '''both''' 32-bit and 64-bit systems, but you should decide '''in advance''' which type of install you want 64 vs. 32-bit - ditto for all tool installs. Installation examples:
# C:\Program Files (x86)\        Represents 32-bit software program installation, normal folder location.
# C:\Program Files\                 Represents 64-bit software program installation, normal folder location.
Also, '''both''' folder locations just above frequently and even always exist on most machines, but for consistency and integration purposes the software should be 32 '''or''' 64-bit. Most people choose 64-bit installs if their Windows OS supports the 64-bit architecture, with 32-bit available for backward software compatibility in conjunction with less current systems. If you don't know which architecture your system uses, go to the Control Panel, System Information. Downloads usually get placed into a Downloads folder. Several of the unzipped NARS tools get placed directly into the C:\NARS2000 folder, see individual tools for exact locations. 

To install the Microsoft '''Visual Studio 2013 Express C compiler''', see Downloads(detail, #1 above). Visual C++ 2013 usually installs into something like, "C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\VCExpress.exe" (64-bit loc) and you may want to place a '''Shortcut''' to '''VCExpress.exe''' on your Desktop by right-clicking on that VCExpress.exe file in Windows Explorer and Send To - Desktop (create shortcut). (Windows 8 Users: You can also '''Pin VCExpress.exe To your Taskbar''' for quick, easy access.) (Prior/obs. Microsoft setup routine name: run the vcsetup.exe program.) Afterwards including after drive plus folder remapping - the files '''msobj80.dll''', '''mspdb80.dll''', '''mspdbcore.dll''', and '''mspdbsrv.exe''' all need to be copied from '''V:\Common7\IDE''' to '''V:\VC\bin''', where the '''V''' drive is a substitute/mapping for '''C:\Program Files\Microsoft Visual Studio 9.0'''. See the discussion below on [[#Set_Up_Makefile_Environment_Variables|Set Up Makefile Environment Variables]].

To install the Parser Generator (Bison), see the instructions above. When the Cygwin setup program asks you to choose a '''Default Text File Type''', choose '''DOS/text''' so any committed files are the same as in the version control repository.

To install Doctor Dump SDK, unzip it in a directory at or above %NARSROOT%, this usually means unzipping into folder C:\DoctorDumpSDK. See also discussion below on [[#Set_Up_Makefile_Environment_Variables|Set Up Makefile Environment Variables]].

Install the rest of the tools as per their instructions above, in the Downloads section.

==Install The Source Code==

<ol>
<li>First create a NARS2000 '''root folder''' somewhere on one of your hard drives, perhaps calling it '''NARS2000''', as in '''C:\NARS2000''' (most common) or perhaps at some lower level. The source code and external libraries are typically installed at or into this level, e.g. qdebug.zip into C:\NARS2000 as C:\NARS2000\qdebug.</li>
<li>Under the root folder make three folders: '''trunk''', '''msieve''', and '''branches'''. The first folder ('''trunk''') will hold the main body of NARS/APL built exe interpreter '''source''' code. The second ('''msieve''') will be utilized for code used to '''factor numbers''', and the third ('''branches''') will contain individual developer branches of the main code not as yet ready for release, but made public for other developers to see.</li>
<li>Using a Version Control program such as '''TortoiseSVN''', download-checkout the source code (see [[#Check_Out_The_Source_Code|Check Out The Source Code]]),</li>
<li>Download the '''misc.zip''', '''qdebug.zip''', '''gsldir.zip''', and '''mplibs.zip''' files into the root folder and unzip them (directly into that root folder, e.g. C:\NARS2000) using e.g. '''7z.exe''' (unzip/extract program used) as in '''7z x misc.zip''', '''7z x qdebug.zip''', '''7z x gsldir.zip''', and '''7z x mplibs.zip''' - or double-click on those downloaded zip file names using Windows File Explorer and Extract All (again typically directly into NARS root folder previously set up).</li>
</ol>

==Check Out The Source Code==

An easy way to initialize your copy of the source code for the first time, although it may initially appear cumbersome to an SVN newcomer, is to use a version control program such as TortoiseSVN, mentioned above. One very helpful feature of TortoiseSVN is that it integrates well with Windows File Explorer. After downloading and installing TortoiseSVN and then rebooting your PC, there are two directories you will need to Install/initialize-checkout/TortoiseSVN-on.
# '''First''' bring up Windows Explorer, right-click on the '''trunk''' folder you manually created, and choose '''SVN Checkout'''.
## If you do not see "SVN Checkout" when you right-click on the '''trunk''' folder, download '''Tortoise SVN''' per the '''Tortoise SVN link above'''([[#Downloads|Downloads-NARS2000 Source Code-Tortoise SVN]]. The online NARS SourceForge URL of source code repository: is '''svn://svn.code.sf.net/p/nars2000/code/trunk''' and your local Checkout directory: is '''C:\NARS2000\trunk''' (or wherever your trunk folder is) - quite likely you will have to edit the TortoiseSVN repository field or program local folder field because default text inserted by TortoiseSVN usually does not match folder location(s) identically. Depth should show Fully recursive, the default.
## To begin source code downloading/checkout into your locally created '''trunk''' folder click the '''OK''' button. Code downloading/checkout should then begin. With a high-speed Internet connection, time required to TortoiseSVN download/checkout NARS code is on the order of roughly two minutes. When successfully complete, you should get a return message at the end of the downloads list, like '''Completed at revision nnnn'''.
# '''Second''' (and this is a similar repeat step but using folder '''msieve''' instead of trunk), bring up Windows Explorer, right-click on the '''msieve''' folder you likewise manually created - and choose '''SVN Checkout...'''. This time online NARS '''URL of repository:''' is '''svn://svn.code.sf.net/p/nars2000/code/msieve''' (this address is slightly different than step 1) and your local '''Checkout directory:''' is '''C:\NARS2000\msieve''' (or wherever your '''msieve''' folder is). Again, depth should be fully recursive and click the '''OK''' button to begin. This step two normally completes in under five seconds, downloading far fewer files than the trunk download. Normally, the same msieve revision number should appear after finishing this download as per trunk download in step 1.

The above '''two''' steps/distinct-folders need be initialized this first checkout time through - in order to establish the special hidden SVN directories for subversion "synching" between your local source code and NARS online code repository. As a brief check that your '''local''' NARS source code files match NARS, there should be green check marks on folders trunk and msieve on your PC, placed there by TortoiseSVN. [http://tortoisesvn.net/docs/release/TortoiseSVN_en/tsvn-dug-wcstatus.html TortoiseSVN Status Information.]

You will still or now need to download and unzip '''qdebug.zip''', '''misc.zip''', '''gsldir.zip''', and '''mplibs.zip''' as described above.

Subsequently, you may quickly and easily update your local copy of NARS source code by right-clicking on the '''trunk''' and/or '''msieve''' folders and choose '''SVN Update'''. One useful feature of sub-versioning programs such as TortoiseSVN is that only '''changed files''' from the online latest official version will need to be subsequently downloaded as changes are made in futuro, re subsequent NARS revisions.

Since you may be unfamiliar with the download process your first time through, it make take slightly longer; however, the second or third time you Check Out The Source Code, over time, the entire "update to most current NARS source code revision" process will probably take under 3 to 5 minutes total, depending however on your (high-speed) Internet service provider's(ISP) download speed.

==Folders==

After unzipping the above files, the structure under the '''NARS2000 root folder''' should look very much like the following('''leftmost column'''), where lower level sub-directories and individual sub-folder file names have been omitted:
{|class="wikitable"| style="width: 40%; border:1px dotted blue;"
!'''NARS2000''' SubFolder:
! Downloaded Zip '''Source''' File or Checkout Process:
|-
| branches\
| class="Unicode" style="text-align:center;" | Created manually(1)
|-
| ecm\
| class="Unicode" style="text-align:center;" | '''mplibs'''.zip
|-
| gsl\
| class="Unicode" style="text-align:center;" | '''gsldir'''.zip
|-
| mpfr\
| class="Unicode" style="text-align:center;" | '''mplibs'''.zip
|-
| mpir\
| class="Unicode" style="text-align:center;" | '''mplibs'''.zip
|-
| msieve\
| class="Unicode" style="text-align:center;" | TortoiseSVN Checkout '''msieve'''
|-
| qdebug\
| class="Unicode" style="text-align:center;" | '''qdebug'''.zip
|-
| trunk\
| class="Unicode" style="text-align:center;" | TortoiseSVN Checkout '''trunk'''
|-
| trunk\binaries\
| class="Unicode" style="text-align:center;" | TortoiseSVN Checkout '''trunk'''
|-
| trunk\Extensions\
| class="Unicode" style="text-align:center;" | TortoiseSVN Checkout '''trunk'''
|-
| trunk\htdocs\
| class="Unicode" style="text-align:center;" | TortoiseSVN Checkout '''trunk'''
|-
| trunk\images\
| class="Unicode" style="text-align:center;" | TortoiseSVN Checkout '''trunk'''
|-
| trunk\MediaWiki\
| class="Unicode" style="text-align:center;" | TortoiseSVN Checkout '''trunk'''
|-
| trunk\ReleaseNotes\
| class="Unicode" style="text-align:center;" | TortoiseSVN Checkout '''trunk'''
|-
| trunk\WineHQ\
| class="Unicode" style="text-align:center;" | TortoiseSVN Checkout '''trunk'''
|-
|}
(1) Subfolder '''\branches''' should be '''created manually''' (e.g. Windows Explorer, right-click, New, Folder). It is used to hold subprojects you may develop. For example if your name is Bill Gates, you might have the following subfolders, each representing a NARS subproject: 
C:\NARS2000\branches\bgates\NARS_Spreadsheets 
C:\NARS2000\branches\bgates\NARS_WordProcPlusAPLEdits 
C:\NARS2000\branches\bgates\EZMenus 
C:\NARS2000\branches\bgates\Graphics 

==Choose How To Build==

The following sections describe two alternate ways to build the executable. One is the GUI interface of VC++ Express, the other is a command line interface using a '''makefile'''.

==Set Up VC++ Express==

If you are using Visual Studio 2013/VC++ Express, the project file is in the '''trunk''' folder and is called '''NARS2000.vcproj'''. You may load it manually every time you invoke VC++ Express, or you may load it automatically by placing the path to the project file on the command line in the VC++ Express shortcut as in '''"C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\VCExpress.exe" C:\NARS2000\trunk\NARS2000.vcproj''' or wherever you defined your NARS2000 root folder.

The vast majority of the project settings are found in the above file with some exceptions.

==Set Up Makefile and Environment Variables==

<hr width=25%>
'''Windows 8''': Setting up Environment and Path Variable(s):
Under Settings, Control Panel, System and Security, System, Advanced System Settings, Advanced (Tab) '''or''' in Control Panel Search for '''Environment Variables''',
* Click '''Environment Variables''' button - There is both a '''Temp Variable''' and '''Path Variable'''.
:: There are 2 sections, User Account Variables and System Variables. You normally want to add new '''System Variables'''.
::: Click '''[New]''' button for a New System Variable:
:::: Variable name       '''PARGEN'''
:::: Variable value       '''C:\cygwin64\bin\bison'''       << typical for a 64 bit install(for bison.exe in subfolder bin), for 32 bits installs see below for variable '''set''' values.
* Normally add a '''New''' variable (var Name plus Value) for each of the '''eight Set''' vars commands listed below, 8 environment variable names - such as NARSROOT, CS_DIR, ZIPPRG, PARGEN, etc.
* If you need to add another Path to an existing variable, each new or added path is separated with a semi-colon.
* After updating any Environment/Path variable(s) you apparently need to reboot since the above variable changes only affect changes in the Registry until PC is rebooted.
* The instructions below should also or alternatively work.
<hr width=25%>
If you are building from the '''makefile''' or working with the GUI C++ Compiler, you'll need to set '''eight environment variables''' in your '''autoexec.bat''' file ('''or''' see just above for setting Environment Variables via '''Windows Control Panel'''). Note that ''Environment variable #n's'' just below are shown only for helpful reference purposes.
<pre>
REM Path of the root of the NARS2000 project *ending with a backslash*
Set NARSROOT=C:\NARS2000^\                         Environment variable #1

REM Path to Doctor Dump SDK root
Set CS_DIR=C:\DoctorDumpSDK^\                      Environment variable #2

REM Path and name of zip program (7-Zip)
Set ZIPPRG="C:\Program Files\7-Zip\7z"             Environment variable #3

REM Path and name of parser generator (bison)      Environment variable #4 (next line)
Set PARGEN=C:\Cygwin\bin\bison         OR for a 64-bit install >>   Set PARGEN=C:\cygwin64\bin\bison

REM Path and name of makedep program
Set MAKEDEP=%NARSROOT%makedep.php                  Environment variable #5

REM Path and name of the <makepro.php> program
Set MAKEPRO=%NARSROOT%makepro.php                  Environment variable #6

REM Folder of SDK ("C:\Program Files\Microsoft SDKs\Windows\v7.0A")
Set SDK=U:^\                                       Environment variable #7

REM MSVC compiler ("C:\Program Files\Microsoft Visual Studio 9.0")
Set MSVC=V:\VC^\                                   Environment variable #8
</pre>
<hr width="75%">
'''Mapping Virtual Drive Letters:''' 
You will be using Windows '''subst''' command to map drive letters as references to drives '''U:''' and '''V:''' that several of the above '''environment variables''' refer to. Microsoft explanation of '''[https://technet.microsoft.com/en-us/library/bb491006.aspx subst command here]'''. 
Modify your C:\AutoExec.bat file to include something approximating the following highlighted text(version#/32/64 bit installs each vary), '''include''' the enclosing quote chars just below: 
'''subst U: "C:\Program Files\Microsoft SDKs\Windows\v7.0A"'''      (or whatever your current version is) 
'''subst V: "C:\Program Files\Microsoft Visual Studio 9.0"'''             (ditto re version 9.0=Visual Studio 2008)
 
If you do not have an '''AutoExec.bat''' file (many '''Windows 7 and 8''' users may not):
: Create a new text document using Windows File Explorer, rename it as AutoExec.bat and move(or copy) it to the '''C:\''' drive folder '''with the above two subst''' commands in it.
: Windows 7 and 8 users: File AutoExec.bat no longer automatically gets run at system-user boot-up so '''place a Shortcut to AutoExec.bat''' in the Program files '''Startup''' folder location(navigate Windows File Explorer to '''one''' of the below locations, right-click, '''New''', '''Shortcut''', '''AutoExec.bat'''). The Windows 7/8 Startup Folder usually is located as follows:
:: C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Startup                                         (general/all users Startup folder) '''OR'''
:: C:\Users\'''UserName'''\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup       (single user Startup folder, '''UserName varies''')
'''IMPORTANT''': A successfully mapped '''V''' drive should contain a sub-sub-subfolder which then contains the '''amd64\nmake.exe''' (64-bit systems) file or '''bin\nmake.exe''' (32-bit systems), e.g. '''typical''' 64-bit configuration/location: '''C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\bin\amd64\nmake.exe'''.
:The V drive map would '''only''' include linking through subfolder '''\Visual Studio 9.0'''. After creating the linked drives, just '''check''' to make sure your mapped '''V''' drive has the '''nmake.exe''' contained one or several subfolder levels below it. The NARS2000.exe automated Compile/Build uses '''nmake.exe''' during exe construction. 64-bit installs require the '''amd64\nmake.exe''' file - paradoxically even if your machine's chipset is Intel, a minor Microsoft variation. 
Typical mapped configurations just below, but again each install/version# may vary: 
'''U''' =     '''C:\Program Files\Microsoft SDKs\Windows\v7.0A'''     (or v6.0A or whatever your downloaded/current version is) 
'''V''' =     '''C:\Program Files\Microsoft Visual Studio 9.0'''           (or '''C:\Program Files (x86)\Microsoft Studio 9.0''' for 64-bit installs, again look for nmake.exe in a subfolder) 
As a '''check''' to make sure the '''subst''' commands worked, there should now be '''2 new drive letters visible in Windows Explorer, in the leftmost window for virtual drives/mapped folders - U and V'''. ''To avoid having to reboot'' at present, just '''open'''(not edit but run) '''AutoExec.bat AFTER''' making sure it is 100% correctly configured. Having a correctly configured AutoExec.bat file will ensure not having to manually link drives U and V each time the NARS2000.exe is built-rebuilt.
<hr width="40%">
If you install NARS project tools in other folders, make appropriate changes to the above mappings.

'''Lastly don't forget:''' To append three folders: '''C:\cygwin64\bin''' , '''V:\Common7\IDE''' and '''C:\PHP''' to your '''Path''' variable '''PATH=%PATH%;C:\cygwin64\bin;V:\Common7\IDE;C:\PHP''' or see '''Control Panel''' search for '''Path''', then '''Edit''' System Environment Variables for your account, system variable named '''Path'''; append to that '''Path''' variable   ''';C:\cygwin64\bin;V:\Common7\IDE;C:\PHP'''   - (three additional paths, semicolon separated) so Visual C's '''Make''' plus '''Compiler''' can find DLLs, exe's and Tools you have so diligently downloaded, then installed.

==Pre First Compile and Localization Notes==

Make/Compile local Environment Variable '''%NARSROOT%''' is presently set using file '''C:\NARS2000\trunk\wcustomize.bat'''. This bat file is called by other major trigger-compile bat files such as mk32.bat, mk64.bat, w32.bat and w64.bat - which oversee-initiate compilation. The %NARSROOT% environment variable is important in indicating where Make/Compilation will occur. Before first locally compiling NARS2000, you likely need to manually edit (using Notepad or a local text file editor) file '''trunk\wcustomize.bat''' and make sure the following are initially correct per your 'local PC NARS installation' i.e. within wcustomize.bat: 
'''Set NARSROOT=C:\NARS2000^\'''       (Note: '''No %''' symbols are needed in set/specification rows in wcustomize.bat, e.g. replace 'R:\NARS2000' to 'C:\NARS2000' as shown at left) 
'''Set CS_DIR=C:\DoctorDumpSDK^\'''     (again R:\ was changed to C:\) 
The additional hat(^) symbol in the above bat commands is needed for directory/folder recombination purposes, essentially sub-directory parse-point identification and or recombination point, where NARS may use subdirectories/parsing.

'''Prior''' to using '''Visual Studio''' and its '''IDE'''(integrated developer's environment) for NARS Building/Compilation purposes a first time, and to help ensure the proper installation of NARS source code - it is very helpful/necessary to open a CMD.EXE window using <big>'''Windows Start''', '''CMD.EXE'''</big>. This will open up a small CMD window. While <big>inside the opened CMD.EXE window</big>, navigate to your local C:\NARS2000\trunk folder, using <big>'''cd C:\NARS2000\trunk'''</big> where cd represents change directory. Now run <big>'''mk32.bat'''</big> by typing it in, to compile NARS2000's 32-bit executable. If mk32.bat is successful and if your installation is 100% correct, two identical files in separate folders will be created(built and compiled) using bat commands from inside that CMD window/session: 
'''C:\NARS2000\trunk\RET\ND32\NARS2000.exe''' 
'''C:\NARS2000\trunk\binaries\ND32\NARS2000.exe''' 
If that 32-bit NARS make/build was successful, then from the same CMD.EXE window, type <big>'''mk64.bat'''</big>. This should likewise compile locally the '''64-bit''' NARS Executable, with again two resulting '''exe output files:''' 
'''C:\NARS2000\trunk\RET\ND64\NARS2000.exe''' 
'''C:\NARS2000\trunk\binaries\ND64\NARS2000.exe'''

Successfully completing mk32.bat and mk64.bat along with presence of their respective '''NARS2000.exe''' output files generally confirm successful installation of NARS source code, as well as correct installation for several associated tandem utility tools re compiling NARS2000.exe on your server, PC, notebook or tablet computer.

==Building The Executable==

Congratulations, if you've successfully arrived at this section, your resume now includes such useful terms as software installation wizard and relentless software engineering candidate. You are part of an elite group - the few, the proud, NARS geek marines; also known as tomorrow's APL-symbol-set event-horizon squad. You've managed to easily or otherwise cross several potentially deep programming ravines in the process.

At this point you should be ready to build the executable, again - this time however from inside Visual Studio's IDE(integrated developer's environment). There are two general ways to build NARS executable. Method one: Involves the time-honored command-line batch file compile mode using files mk32.bat or mk64.bat - as you should have previously discovered in the section '''[[#Pre_First_Compile_and_Localization_Notes|Pre First Compile and Localization Notes]]''' while using Windows CMD.EXE.

Method two: Involves again first opening a (Windows Start button) '''CMD.EXE''' window and running '''w32.bat start''' (all one command) or '''w64.bat start'''. Immediately or shortly, you should see Visual Studio 2013's program visualize, load and run - with either the 32-bit or 64-bit NARS2000 project/program loaded. After Visual Studio 2013 finishes loading - simply click Build. Full use of Visual Studio 2013's IDE (integrated developer's environment) should now be available for you to experiment with, develop code on, debug and customize APL as you may choose. Your first time through with running '''w32.bat start''' and '''w64.bat start''':
* There is usually a Visual Studio '''One Way Migration''' message which displays. This is normal, TBE(to be expected), and yes you DO at that point want to migrate the NARS2000 project to Visual Studio 2013. There are usually roughly 20 migration warnings which also show up in an Internet Browser page re the Migration Report - again, all normally to be expected. However, there should be '''zero errors''' in the migration report.
* If all went satisfactorily well with the Migration, you should be able to select/choose/Click '''Build Solution''' under Build in VS2013's IDE to fully compile NARS2000 executable. After Build, there should likewise be zero errors.

Special note regarding '''w32.bat start''' and '''w64.bat start''' while in Visual Studio's IDE for the NARS2000 project:
When switching between 32 and 64-bit versions, i.e. w32.bat start '''versus''' w64.bat start: There is a '''Property''' adjustment required when using Visual Studio's IDE. After Visual Studio opens up and in the Solution Explorer window (usually on the upper right hand side of your screen) click on "Solution 'nars2000' (1 project)." This should then show a Properties Window just below it. Look for a line which reads: '''Active config'''. If you ran w32.bat start then Active config should have a value of '''Debug32|Win32'''. If you ran w64.bat start then Active config should have a value of '''Debug64|Win32'''.

== NARS Systems Developer Suggested Knowledge Prequisites ==

For a strongly recommended set of knowledge prerequisites - in order to effectively understand, maintain or improve NARS functionality - please see '''[[NARS System Developer Suggested Knowledge Prerequisites|NARS System Developer Suggested Knowledge Prerequisites]]'''.

==Developer Experiments with NARS Source Code==

This section is for Developers who have successfully downloaded NARS source code and want to Experiment with it, or further develop NARS APL Interpreter's source code.

For development and debugging purposes: You as APL Interpreter developer normally want to want to first write new source code/model using the 32-bit version of NARS2000 (w32.bat start). This is because the 32-bit version is easier to debug than the 64-bit version; error messages can be less complex. Migrating '''correct source code''' forward from the 32-bit version to the 64-bit version is also easier than a reverse migration.

You will also at some point still need to be synched-with or later synch-back-to NARS online source code - i.e. after experimenting/changing local PC source code. This is equivalent to a ChemLab 101 at home/home-office and cleaning up all experiments at the end of the chemistry class, except as it applies to software developers, NARS software developers, and or those inclined to experiment safely.

Here is where Tortoise SVN provides excellent and time-tested source-code clean-up tools for your local PC, including '''Resolve, Revert, Clean up, and Undo changes'''. Pull up these TortoiseSVN utilities by navigating Windows File Explorer to directory C:\NARS2000. If you successfully previously downloaded and Installed TortoiseSVN and NARS2000 source code, as outlined earlier/above, you may right click on say the \trunk subfolder in C:\NARS2000. A mouse right-click on \trunk should show an option labeled TortoiseSVN. Further choosing/selecting TortoiseSVN should then reveal multiple clean up options - Resolve, Revert, Clean up and Undo changes. '''TortoiseSVN Documentation on:''' [http://tortoisesvn.net/docs/release/TortoiseSVN_en/tsvn-dug-cleanup.html Clean up.] [http://tortoisesvn.net/docs/release/TortoiseSVN_en/tsvn-dug-revert.html Undo Changes.] [http://tortoisesvn.net/docs/release/TortoiseSVN_en/tsvn-dug-conflicts.html Resolving Conflicts.] 

At least one method to safely synch-back-to NARS is to:
# Select '''TortoiseSVN''' after right-clicking on the trunk folder
# Select '''Revert''', click '''OK''', let it run.
# Select '''Clean up''', check '''Refresh shell overlays''', click '''OK''', let it run.
Per TortoiseSVN there should again be green check marks appearing on your trunk folder as well as your msieve folder.

For revision tracking and long-term software program maintenance purposes: '''Keep track of which files (file names) you personally modify, including a brief purpose''' for that edit. You will need to this information later for Release Notes purposes (see folder C:\NARS2000\trunk\ReleaseNotes for best-practice-examples of developer note-taking) and if you later synch to a new online NARS version, you may have to carry-forward your edit changes into a newly downloaded set of NARS source code files which may or may not reflect your prior local computer edit changes.

==Periodic NARS Updates==

Incremental Update - Method 1: 
Periodically, NARS APL interpreter developers should ensure changes done by other developers get incorporated into their local machine's source code working copy. This is the process of integrating/downloading changes from NARS SourceForge server '''to''' your local copy. Updating may be performed on single files, a set of selected files, or recursively on entire directory hierarchies. To update, select the files and/or '''directories''' you want (usually \trunk and or \msieve), right click and select '''TortoiseSVN → Update''' in the explorer context menu for that trunk or msieve folder. A window will pop up displaying the progress of the update as it runs. Changes done by other developers will be merged into your local files, '''keeping''' any changes you may have done to the same files - if you did not want to keep your local changes but do want to keep the downloaded changes, select TortoiseSVN and Revert '''prior''' to running TortoiseSVN Update. NARS repository at SourceForge is '''not''' affected by an update to your local copy. [http://tortoisesvn.net/docs/nightly/TortoiseSVN_en/tsvn-dug-update.html Update Your Working Copy With Changes From Others]

Total Source Code Replacement - Method 2: 
For example from version r1325 to say version r1364 (note a significant revision/datetime gap between 1325 and 1364, hypothetically), whatever NARS latest revision number is. Total code replacement may be preferred over incremental updating when major structural changes or significant source code changes are newly in situ. 
Total Replacement Process: Visually scan NARS source code page at http://sourceforge.net/p/nars2000/code/HEAD/tree/trunk/ and review the top 25 to 40 file entries or so, while mentally keeping track of the '''highest revision number found'''(e.g. r1379). If after your last/earlier TortoiseSVN Update, your local version number is lower than the latest revision number visually found online, then perform the following to update to the most recent NARS revision:
# Rename your existing NARS folder to something approximating C:\NARS2000_old_rev
# Create an entirely new C:\NARS2000 folder
# '''Copy all folders and files at the top level''' from C:\NARS2000_old_rev folder into C:\NARS2000 '''EXCEPT \trunk and \msieve subfolders (and their contents)'''. The \trunk and \msieve folders will shortly be downloaded from SourceForge.
# Create '''new empty folders called \trunk and \msieve''' in the new C:\NARS2000 folder.
# Revisit the section above called '''[[#Check_Out_The_Source_Code|Check Out The Source Code]]''' to again checkout/download to the absolute latest NARS version number, for both \trunk and \msieve folders.
# Also revisit '''[[#Pre_First_Compile_and_Localization_Notes|Pre First Compile and Localization Notes]]''' and text edit file \trunk\wcustomize.bat to localize the new version.
# Folder C:\NARS2000_old_rev may be '''Recycled''' after you are done copying non-trunk and non-msieve files/folders from it into your new C:\NARS2000 folder. If disk space is not restrictive and for 100% safety purposes, keep your prior folder available until after successfully '''Building/Compiling''' the newly downloaded 32-bit and 64-bit versions, and making sure you did not have any local personal changes now potentially being recycled.

[[Category:NARS 2000]]