Special Code

An Implementation of J

Many primitives contain special code for certain arguments to effect time and/or space savings not available to general arguments. Moreover, some phrases are "recognized" and are supported by special code. For example, the dyad of the hook (\$,) is exactly the reshape of APL (denoted by r); its implementation avoids actually ravelling the right argument, and in so doing saves both time and space:

```   ts=: 6!:2 , 7!:2@]
x=: 11 13 17 19 23
y=: 29 7 23 11 19\$'sesquipedalian'

(x (\$,) y) -: x \$, y
1

ts 'x (\$,) y'
0.00773981 2.09818e6
ts 'x \$, y'
0.0170125 3.14662e6```

Instances of such special code are listed below:

```=               dyad    word-parallel operation on Boolean arguments for the following verbs:
= < <. <: > >. >: +. +: * *. *: ^ ~: | !
<.@f            both    avoids non-integer intermediate results on extended precision integers
>.@f            both    avoids non-integer intermediate results on extended precision integers
+               dyad    also * and -; on Windows, assembly code for integer arguments for the
vector-vector, vector-scalar, and scalar-vector cases
^               dyad    x^y works by repeated multiplication if x is real and y is integral
m&|@^           dyad    avoids exponentiation for extended precision arguments
m&|@(n&^)       monad   avoids exponentiation for extended precision arguments
-/ .*           monad   special code in general; special code for square matrices; special code
for arrays of 2-by-2 matrices
\$,              dyad    also (\$,)"r; avoids ravel
f;.1            both    also f;._1 f;.2 f;._2; avoids building argument cells for several verbs:
< \$ , # [ ] {. {: <@}. <@}: ; also <&}. <@:}. etc.
f;.3            both    also f;._3; special code for matrix right arguments
#               dyad    special code for Boolean left arguments
# i.@#          monad   also (# i.&#), etc.; avoids i. on Boolean arguments
#: i.@(*/)      monad   also (#: i.&(*/)), etc.; special code for non-negative integer vectors
=/              monad   also < <: > >: +. +: * *. *: ~:; word-parallel operations on Boolean arguments
+/              monad   also * and -; on Windows, assembly code for integer arguments
f/@,            monad   also f/@:, f/&, f/&:,; avoids ravel
#/.             dyad    avoids building argument cells
/:              both    also \:; special code for several data types; special code for arguments
with 5 items or less
=/\             monad   also +. *. ~:; word-parallel operations on Boolean arguments
+/\             monad   also * and -; on Windows, assembly code for integer arguments
=/\.            monad   also < <: > >: +. +: *. *: ~:; word-parallel operations on Boolean arguments
+/\.            monad   also * and -; on Windows, assembly code for integer arguments
{               dyad    special code for right arguments of several data types; special code for
integer left arguments; special code for indexing first two axes
<"1@[ { ]       dyad    avoids <"1 if left argument is integer array
a=: c}x,y,:z    -       avoids catenation and lamination; in-place if c is Boolean and a is x or y
y=: x i}y       -       in-place
f"r             both    numerous verbs have integrated rank support:
= < <. <: > >. >: + +. +: * *. *: - -: % ^ ~: | |. |: \$ , ,. ,: # ! [ ] {
{. {: }. }: / /: \ \. \: e. i. i: o. p. p:
?               monad   also ?.; special code if argument is identically 2
?               dyad    also ?.; special code if left argument is much smaller than right argument
E.              monad   special code for Boolean and literal vector arguments
i.              monad   also i:; special case for length-1 arguments
i.              dyad    also e. and i:; special code for several data types; special code for i.!.0;
special code for arguments with many identical columns```