Theme:
v
MACfns 4.0 Groups of Functions
Here is a list of all MACfns Assembler functions grouped by various criteria (some functions are listed several times).
MACfns and files
----------------
GetMACfns Get MACfns, assembler code, documentation, or APL analog.
MACfnsFid Return name of file used by GetMACfns (var or niladic fn).
∆CPULEVEL CPU level for MACfns.
∆DOSHAND  Convert tie number to DOS handle.

Dates
-----
∆CHKTS    Check ⎕TS-form timestamp.
∆DATEBASE Compute days since 1Jan1900 from YYYY MM DD dates.
∆DATEPACK Pack YYYY MM DD dates as scalars {per L={0-5}}.
∆DATEREP  Compute YYYY MM DD dates from days since 1Jan1900.
∆DATEUNP  Unpack scalars as YYYY MM DD dates {per L={0-5{,cuspyear}}}.
∆DATE2BAS Compute days since 1Jan1900 from two YYYY MM DD dates.
∆DATE2REP Compute YYYY MM DD dates from two days since 1Jan1900.
∆DOSTS    Check and pack ⎕TS-form timestamp as scalar.
∆DOST     Unpack scalar into ⎕TS-form timestamp.
∆CHK2DS   Check two 3↑⎕TS-form datestamps.
∆DOS2DS   Check and pack two 3↑⎕TS-form datestamps as scalar.
∆DOS2D    Unpack scalar into two 3↑⎕TS-form datestamps.

Datatype manipulation and internal representation
-------------------------------------------------
∆ALLOC    Allocate arbitrary array of ⎕DR type L and shape R.
∆AF       Atomic function:  ⎕AV[⎕IO+R] or (⎕AV⍳R)-⎕IO
∆CDR      Change data representation:  L ⎕DR R ⍝ singleton L
∆BREPI    32-column Boolean representation of integer:  ⍉1=(32⍴2)⊤⍉R
∆IREPB    Integer representation of 32-col Boolean:  ⍉(0 ¯2,30⍴2)⊥⍉R
∆ENDIAN   Reverse byte order of integer or floating point values.
∆COERCE   Coerce numeric or empty R to type L∊11 323 645.
∆DEMOTE   Demote numeric items to most compact representation.
∆CRC      Cyclic redundancy 32-bit check for simple R.
∆DRe      Data representation each:  ⎕DR¨R
∆DRNe     Data representation each, negating nested:  (⎕DR¨R)ׯ1*×≡¨R

Character translation
---------------------
∆AF       Atomic function:  ⎕AV[⎕IO+R] or (⎕AV⍳R)-⎕IO
∆BTCCS    Blank terminal control characters.
∆LCASE    Translate to lowercase.
∆LCASEDOS Translate to lowercase for DOS.
∆UCASE    Translate to uppercase.
∆UCASEDOS Translate to uppercase for DOS.
∆XLATE    Translate character R to 256-character L:  L[⎕AV⍳R]

Character searching and changing
--------------------------------
∆AF       Atomic function:  ⎕AV[⎕IO+R] or (⎕AV⍳R)-⎕IO
∆AVEPS    Flag membership of all characters:  ⎕AV∊R
∆AVNUB    Distinct characters:  ⎕AV~⎕AV~R
∆AVFREQ   Frequency of all characters:  +/⎕AV∘.≡,R
∆BEQ      Flag blanks (' '=simple):  R∊' '
∆BNE      Flag nonblanks (' '≠simple):  ~R∊' '
∆NLEQ     Flag newlines (⎕TCNL=simple):  R∊⎕TCNL
∆NLNE     Flag non-newlines (⎕TCNL≠simple):  ~R∊⎕TCNL
∆NULEQ    Flag nulls (⎕TCNUL=simple):  R∊⎕TCNUL
∆NULNE    Flag non-nulls (⎕TCNUL≠simple):  ~R∊⎕TCNUL
∆STS      Flag start of matches of string R in string L:  L ⎕SS R
∆STSNOV   Flag start of nonoverlapped matches of string R in string L.
∆STSF     First index of string R in string L or ↑↓/L if (2∊⍴L)^⍬≡0⍴L.
∆TXTRPL   Replace strings L ('/old1/new1/old2/new2...') in string R.
∆WRDRPL   Replace words L ('/old1/new1/old2/new2...') in string R.
∆UNTAB    Replace tabs in string R {L={tabinc{,tab{,fill{,⊂dels}}}}}.
∆NLLF     Insert LF's after NL's in string, or NL,LF's between rows.
∆XLATE    Translate character R to 256-character L:  L[⎕AV⍳R]

Character data restructuring
----------------------------
∆DTBR     Delete trailing blank rows:  (⌽∨\⌽R∨.≠' ')⌿R
∆CJUST    Center justify character:  (⌈.5×-⌿+/^\' '=⊃R(⌽R))⌽R
∆LJUST    Left justify character:  (+/^\' '=R)⌽R
∆RJUST    Right justify character:  (+/∨\' '≠⌽R)⌽R
∆MATDS    Matrix to delimited string {L={delimiter{,{fill∣¯1}}}}.
∆MATSS    Matrix to segmented string {L={delimiter{,{fill∣¯1}}}}.
∆MATNV    Character matrix to nested vector {L={fill∣¯1}}.
∆DSMAT    Delimited string to matrix {L={delimiter{,fill}}}.
∆DSMATSZ  Delimited string to matrix size {L={delimiter{,ignored}}}.
∆SSMAT    Segmented string to matrix {L={fill}}.
∆SSMATSZ  Segmented string to matrix size {L=ignored}.
∆NVMAT    Nested vector to character matrix {L=fill}:  ⊃R
∆SSLENS   Segment lengths in segmented string.
∆SSSHAPE  Number of segments in segmented string:  +/R=1↑R

Formatting
----------
∆I11FMT   Integer 11-column formatting:  'I11'⎕FMT simple
∆I12FMT   Integer 12-column formatting:  'I12'⎕FMT simple

General data restructuring
--------------------------
∆CAT_     Catenate along the first axis:  L⍪R
∆COLMAT   Coalesce trailing (all but the first) axes to form matrix.
∆ROWMAT   Coalesce leading (all but the last) axes to form matrix.
∆ONECOL   Coalesce all axes to form one-column matrix:  ,[⍬],R
∆ONEROW   Coalesce all axes to form one-row matrix:  ,[⎕IO-.5],R
∆REVA     Reverse all axes (matrix ⊖⌽R):  (⍴R)⍴⌽,R
∆EXTEND   Truncate or pad raveled R with last item to shape L.
∆ENCLOSEe Enclose each (⊂[⍬]R):  ⊂¨R
∆SOSNV    Scalar or simple to nested vector:  ⍎(1=≡R←1/R)/'R←,⊂R'

Data selection
--------------
∆INDEX_   First axis indexing (matrix L[R;]):  (⊂R)⌷[⎕IO]L
∆SQUAD_   First axis indexing (matrix R[L;]):  (⊂L)⌷[⎕IO]R

Indices
-------
∆INDS     Indices of nonzeros in vector (bitvec R/⍳⍴R):  (~R∊0)/⍳⍴,R
∆ZNDS     Indices of zeros in vector (bitvec (~R)/⍳⍴R):  (R∊0)/⍳⍴,R
∆ODOMETER Generalized odometer:  ⊃,↑∘.,/,R ⍝ nested array of intvecs
∆DTBLENS  Length of rows sans trailing blanks:  +/∨\' '≠⌽R
∆ROWFIND  Flag rows of character L containing vector R:  ∨/R⍷1/L
∆ROWIOTA  Locate rows of R in matrix L; ⎕IO-1 if not found ⍝ ⎕CT=0
∆ROLL     Random integers from ⍳¨R (?R) or of shape L from ⍳R (?L⍴R).
∆SSLENS   Segment lengths in segmented string.

Logical functions
-----------------
∆NOT      Logical negation:  ~R ⍝ bit
∆AND      Logical and:  L^R ⍝ bit
∆ANDNOT   Logical and not:  L>R ⍝ bit
∆OR       Logical or:  L∨R ⍝ bit
∆ORNOT    Logical or not:  L≥R ⍝ bit
∆NAND     Logical not and:  L⍲R ⍝ bit
∆NANDNOT  Logical not and not:  L≤R ⍝ bit
∆NOR      Logical not or:  L⍱R ⍝ bit
∆NORNOT   Logical not or not:  L<R ⍝ bit
∆XOR      Logical exclusive or:  L≠R ⍝ bit
∆NXOR     Logical not exclusive or:  L=R ⍝ bit
∆opAND    Outer product logical and:  L∘.^R ⍝ bit

Relational functions
--------------------
∆MATCH    Flag if arrays identical:  L≡R ⍝ ⎕CT=0
∆EMATCH   Flag if arrays identical (L≡R with ⎕CT=0), including ⎕DR.
∆ALL      Flag if all ones (^/,bit, ^/,1=simple):  ~0∊R∊1 ⍝ ⎕CT=0
∆ANY      Flag if any ones:  1∊R ⍝ ⎕CT=0
∆ANYe     Flag if any ones in each (1=simple):  1∊¨R ⍝ ⎕CT=0
∆NALL     Flag if not all ones (~^/,bit, ∨/,1≠simple):  0∊R∊1 ⍝ ⎕CT=0
∆NONE     Flag if no ones:  ~1∊R ⍝ ⎕CT=0
∆ALLZ     Flag if all zeros (~∨/,bit, ^/,0=simple):  ~0∊R∊0
∆ANYZ     Flag if any zeros:  0∊R
∆NALLZ    Flag if not all zeros (∨/,bit, ∨/,0≠simple):  0∊R∊0
∆NOZ      Flag if no zeros:  ~0∊R
∆EVEN     Flag even values:  0=2∣⌊∣R ⍝ ⎕CT=1<≡R
∆ODD      Flag odd values:  0≠2∣⌊∣R ⍝ ⎕CT=1<≡R
∆ZEQ      Flag zeros (0=simple):  R∊0
∆ZNE      Flag nonzeros (0≠simple):  ~R∊0
∆ZGT      Flag negative items:  0>R ⍝ 1≥≡R
∆ZLT      Flag positive items:  0<R ⍝ 1≥≡R
∆ZLE      Flag nonnegative items:  0≤R ⍝ 1≥≡R
∆ZGE      Flag nonpositive items:  0≥R ⍝ 1≥≡R
∆BEQ      Flag blanks (' '=simple):  R∊' '
∆BNE      Flag nonblanks (' '≠simple):  ~R∊' '
∆NLEQ     Flag newlines (⎕TCNL=simple):  R∊⎕TCNL
∆NLNE     Flag non-newlines (⎕TCNL≠simple):  ~R∊⎕TCNL
∆NULEQ    Flag nulls (⎕TCNUL=simple):  R∊⎕TCNUL
∆NULNE    Flag non-nulls (⎕TCNUL≠simple):  ~R∊⎕TCNUL
∆NVEC     End partition vector (flag end of runs); ⎕CT=1<≡R.
∆PVEC     Partition vector (flag start of runs); ⎕CT=1<≡R.

Sign manipulation
-----------------
∆SIGN     Sign (¯1 if negative, 1 if positive, or 0):  ×R ⍝ 1≥≡R
∆ABS      Absolute value (magnitude):  ∣R ⍝ 1≥≡R
∆NABS     Negate absolute value (negated magnitude):  -∣R ⍝ 1≥≡R
∆FABS     Floor absolute value (integer magnitude):  ⌊∣R ⍝ ⎕CT=1<≡R
∆NEG      Negate (change sign):  -R ⍝ 1≥≡R
∆NOT      Logical negation:  ~R ⍝ bit
∆NPOW     Negative one power (1=even, ¯1=odd):  ¯1*R ⍝ int
∆NNPOW    Negate negative one power (¯1=even, 1=odd):  -¯1*R ⍝ int
∆ONEMAX   Higher of one or R:  1⌈R ⍝ 1≥≡R
∆ONEMIN   Lower of one or R:  1⌊R ⍝ 1≥≡R
∆ZMAX     Higher of zero or R (zero negative items):  0⌈R ⍝ 1≥≡R
∆ZMIN     Lower of zero or R (zero positive items):  0⌊R ⍝ 1≥≡R
∆HILO     Highest and lowest:  (⌈/,R),⌊/,R ⍝ ⎕DR-based if empty

Rounding
--------
∆CEIL     Ceiling (lowest integer not below):  ⌈R ⍝ ⎕CT=1<≡R
∆FLOOR    Floor (highest integer not above):  ⌊R ⍝ ⎕CT=1<≡R
∆FABS     Floor absolute value (integer magnitude):  ⌊∣R ⍝ ⎕CT=1<≡R
∆FHALF    Floor halve:  ⌊R÷2 ⍝ ⎕CT=1<≡R
∆IRND     Integer round:  ⌊.5+R ⍝ ⎕CT=1<≡R
∆IRNDM    Integer round magnitude:  (×R)×⌊.5+∣R ⍝ ⎕CT=1<≡R
∆F2LOG    Adjusted floor two log:  (¯65536×0=R)+⌊2⍟∣R+0=R ⍝ ⎕CT=1<≡R
∆F10LOG   Adjusted floor ten log:  (1+0>R)+⌊10⍟1⌈∣R ⍝ ⎕CT=1<≡R

Addition and subtraction
------------------------
∆DEC      Decrement by one:  R-1 ⍝ 1≥≡R
∆DEN      Decrement negation by one:  ¯1-R ⍝ 1≥≡R
∆DECH     Decrement by half:  R-.5 ⍝ 1≥≡R
∆INC      Increment by one:  R+1 ⍝ 1≥≡R
∆INN      Increment negation by one:  1-R ⍝ 1≥≡R
∆INCH     Increment by half:  R+.5 ⍝ 1≥≡R
∆NEG      Negate (change sign):  -R ⍝ 1≥≡R
∆NABS     Negate absolute value (negated magnitude):  -∣R ⍝ 1≥≡R
∆ADDR     Add reciprocal ((1+R*2)÷R):  R+÷R ⍝ 1≥≡R
∆SUBR     Subtract reciprocal ((¯1+R*2)÷R):  R-÷R ⍝ 1≥≡R

Multiplication, division, and reciprocal
----------------------------------------
∆DOUB     Double:  R×2 ⍝ 1≥≡R
∆DECD     Decrement double:  ¯1+R×2 ⍝ 1≥≡R
∆HALF     Halve:  R÷2 ⍝ 1≥≡R
∆HINC     Halve increment:  (R+1)÷2 ⍝ 1≥≡R
∆FHALF    Floor halve:  ⌊R÷2 ⍝ ⎕CT=1<≡R
∆HSQAR    Halve square:  (R*2)÷2 ⍝ 1≥≡R
∆HDIV     Half divided by:  .5÷R ⍝ 1≥≡R
∆TWODIV   Two divided by:  2÷R ⍝ 1≥≡R
∆RECIP    Reciprocal:  ÷R ⍝ 1≥≡R
∆SUMRECIP Sum reciprocals in simple R:  +/,÷R
∆NEGR     Negate reciprocal:  -÷R ⍝ 1≥≡R
∆INCR     Increment reciprocal ((R+1)÷R):  1+÷R ⍝ 1≥≡R
∆DECR     Decrement reciprocal ((1-R)÷R):  ¯1+÷R ⍝ 1≥≡R
∆INNR     Increment negated reciprocal ((R-1)÷R):  1-÷R ⍝ 1≥≡R
∆DENR     Decrement negated reciprocal ((¯1-R)÷R):  ¯1-÷R ⍝ 1≥≡R
∆ADDR     Add reciprocal ((1+R*2)÷R):  R+÷R ⍝ 1≥≡R
∆SUBR     Subtract reciprocal ((¯1+R*2)÷R):  R-÷R ⍝ 1≥≡R
∆RINC     Reciprocal increment:  ÷R+1 ⍝ 1≥≡R
∆RDEC     Reciprocal decrement:  ÷R-1 ⍝ 1≥≡R
∆RINN     Reciprocal incremented negation:  ÷1-R ⍝ 1≥≡R
∆RDEN     Reciprocal decremented negation:  ÷¯1-R ⍝ 1≥≡R
∆DIVI     Divide by increment:  R÷R+1 ⍝ 1≥≡R
∆DIVD     Divide by decrement:  R÷R-1 ⍝ 1≥≡R
∆DIVN     Divide by incremented negation:  R÷1-R ⍝ 1≥≡R
∆DIVC     Divide by decremented negation:  R÷¯1-R ⍝ 1≥≡R
∆DIVDI    Divide decrement by increment:  (R-1)÷R+1 ⍝ 1≥≡R
∆DIVID    Divide increment by decrement:  (R+1)÷R-1 ⍝ 1≥≡R
∆DIVIN    Divide increment by incremented negation:  (R+1)÷1-R ⍝ 1≥≡R
∆DIVNI    Divide incremented negation by increment:  (1-R)÷R+1 ⍝ 1≥≡R
∆UTRI     L-row upper triangular mat from vec R:  R×[⎕IO+1](⍳L)∘.≤⍳⍴R

Pi multiplication and division
------------------------------
∆DIVPI    Divide by pi:  R÷○1 ⍝ 1≥≡R
∆DIV2PI   Divide by twice pi:  R÷○2 ⍝ 1≥≡R
∆DIVHPI   Divide by half pi:  R÷○.5 ⍝ 1≥≡R
∆PIDIV    Pi divided by:  ○÷R ⍝ 1≥≡R
∆PI       Pi times:  ○R ⍝ 1≥≡R
∆PIDOUB   Pi times double:  ○R×2 ⍝ 1≥≡R
∆PIHALF   Pi times halve:  ○R÷2 ⍝ 1≥≡R
∆PISQAR   Pi times square:  ○R*2 ⍝ 1≥≡R
∆SQRTDPI  Square root of divide by pi:  (R÷○1)*.5 ⍝ 1≥≡R
∆PIDTR    Degrees to radians:  ○R÷180 ⍝ 1≥≡R
∆PIRTD    Radians to degrees:  R÷○÷180 ⍝ 1≥≡R

Remainders, residue, and modulus
--------------------------------
∆ONEMOD   One modulus (fractional part):  1∣R ⍝ ⎕CT=1<≡R
∆TWOMOD   Two modulus:  2∣R ⍝ ⎕CT=1<≡R
∆EVEN     Flag even values:  0=2∣⌊∣R ⍝ ⎕CT=1<≡R
∆ODD      Flag odd values:  0≠2∣⌊∣R ⍝ ⎕CT=1<≡R
∆NPOW     Negative one power (1=even, ¯1=odd):  ¯1*R ⍝ int
∆NNPOW    Negate negative one power (¯1=even, 1=odd):  -¯1*R ⍝ int

Roots and powers
----------------
∆RECIP    Reciprocal:  ÷R ⍝ 1≥≡R
∆SQAR     Square:  R*2 ⍝ 1≥≡R
∆HSQAR    Halve square:  (R*2)÷2 ⍝ 1≥≡R
∆RSQAR    Reciprocal square:  R*¯2 ⍝ 1≥≡R
∆PISQAR   Pi times square:  ○R*2 ⍝ 1≥≡R
∆SQRT     Square root:  R*.5 ⍝ 1≥≡R
∆SQRTA    Square root absolute value:  (∣R)*.5 ⍝ 1≥≡R
∆SQRTD    Square root double:  (R×2)*.5 ⍝ 1≥≡R
∆SQRTDPI  Square root of divide by pi:  (R÷○1)*.5 ⍝ 1≥≡R
∆RSQRT    Reciprocal square root:  R*¯.5 ⍝ 1≥≡R
∆RSQRTA   Reciprocal square root absolute value:  (∣R)*¯.5 ⍝ 1≥≡R
∆CUBE     Cube:  R*3 ⍝ 1≥≡R
∆CUBERT   Cube root:  (×R)×(∣R)*÷3 ⍝ 1≥≡R
∆FOUTHPW  Fourth power:  R*4 ⍝ 1≥≡R
∆FOUTHRT  Fourth root:  R*.25 ⍝ 1≥≡R

Logarithms and exponentials
---------------------------
∆ELOG     Base-e (natural) logarithm:  ⍟R ⍝ 1≥≡R
∆SUMELOG  Sum base-e (natural) logarithms in simple R:  +/,⍟R
∆EPOW     Base-e (natural) exponential:  *R ⍝ 1≥≡R
∆SINH     Hyperbolic sine:  5○R ⍝ 1≥≡R
∆COSH     Hyperbolic cosine:  6○R ⍝ 1≥≡R
∆TWOLOG   Base-two logarithm:  2⍟R ⍝ 1≥≡R
∆TWOPOW   Base-two exponential:  2*R ⍝ 1≥≡R
∆TENLOG   Base-ten logarithm:  10⍟R ⍝ 1≥≡R
∆TENPOW   Base-ten exponential:  10*R ⍝ 1≥≡R
∆FAC      Factorial:  !R ⍝ int
∆F2LOG    Adjusted floor two log:  (¯65536×0=R)+⌊2⍟∣R+0=R ⍝ ⎕CT=1<≡R
∆F10LOG   Adjusted floor ten log:  (1+0>R)+⌊10⍟1⌈∣R ⍝ ⎕CT=1<≡R
∆NPOW     Negative one power (1=even, ¯1=odd):  ¯1*R ⍝ int
∆NNPOW    Negate negative one power (¯1=even, 1=odd):  -¯1*R ⍝ int

Trigonometric functions
-----------------------
∆SIN      Sine of radians:  1○R ⍝ 1≥≡R
∆SIND     Sine of degrees:  1○○R÷180 ⍝ 1≥≡R
∆COS      Cosine of radians:  2○R ⍝ 1≥≡R
∆COSD     Cosine of degrees:  2○○R÷180 ⍝ 1≥≡R
∆TAN      Tangent of radians:  3○R ⍝ 1≥≡R
∆TAND     Tangent of degrees:  3○○R÷180 ⍝ 1≥≡R
∆ASIN     Arcsine in radians:  ¯1○R ⍝ 1≥≡R
∆ASIND    Arcsine in degrees:  (¯1○R)÷○÷180 ⍝ 1≥≡R
∆ACOS     Arccosine in radians:  ¯2○R ⍝ 1≥≡R
∆ACOSD    Arccosine in degrees:  (¯2○R)÷○÷180 ⍝ 1≥≡R
∆ATAN     Arctangent in radians:  ¯3○R ⍝ 1≥≡R
∆ATAND    Arctangent in degrees:  (¯3○R)÷○÷180 ⍝ 1≥≡R
∆CSC      Cosecant of radians:  ÷1○R ⍝ 1≥≡R
∆SEC      Secant of radians:  ÷2○R ⍝ 1≥≡R
∆COT      Cotangent of radians:  ÷3○R ⍝ 1≥≡R
∆ACSC     Arccosecant in radians:  ¯1○÷R ⍝ 1≥≡R
∆ASEC     Arcsecant in radians:  ¯2○÷R ⍝ 1≥≡R
∆ACOT     Arccotangent in radians:  ¯3○÷R ⍝ 1≥≡R
∆SINC     Sine cardinal of radians:  (1○R)÷R ⍝ 1≥≡R
∆SINCPI   Sine cardinal pi times:  (1○○R)÷○R ⍝ 1≥≡R
∆SINCOS   Sine and cosine of radians:  1 2○⊂R ⍝ 1≥≡R
∆GD       Gudermannian function:  ¯3○5○R ⍝ 1≥≡R
∆AGD      Inverse Gudermannian function:  ¯5○3○R ⍝ 1≥≡R

Pythagorean functions
---------------------
∆PYTH     Hypotenuse of unit tri. from side ((1+R*2)*.5):  4○R ⍝ 1≥≡R
∆APYTH    Side of unit tri. from hypot. (R×(1-R*¯2)*.5):  ¯4○R ⍝ 1≥≡R
∆APYTHA   Side of unit tri. from ∣hypot. ((¯1+R*2)*.5):  ¯4○∣R ⍝ 1≥≡R
∆ZPYTH    Side of unit tri. from other side ((1-R*2)*.5):  0○R ⍝ 1≥≡R

Hyperbolic functions
--------------------
∆SINH     Hyperbolic sine:  5○R ⍝ 1≥≡R
∆COSH     Hyperbolic cosine:  6○R ⍝ 1≥≡R
∆TANH     Hyperbolic tangent:  7○R ⍝ 1≥≡R
∆ASINH    Hyperbolic arcsine:  ¯5○R ⍝ 1≥≡R
∆ACOSH    Hyperbolic arccosine:  ¯6○R ⍝ 1≥≡R
∆ATANH    Hyperbolic arctangent:  ¯7○R ⍝ 1≥≡R
∆CSCH     Hyperbolic cosecant:  ÷5○R ⍝ 1≥≡R
∆SECH     Hyperbolic secant:  ÷6○R ⍝ 1≥≡R
∆COTH     Hyperbolic cotangent:  ÷7○R ⍝ 1≥≡R
∆ACSCH    Hyperbolic arccosecant:  ¯5○÷R ⍝ 1≥≡R
∆ASECH    Hyperbolic arcsecant:  ¯6○÷R ⍝ 1≥≡R
∆ACOTH    Hyperbolic arccotangent:  ¯7○÷R ⍝ 1≥≡R
∆ELOG     Base-e (natural) logarithm:  ⍟R ⍝ 1≥≡R
∆EPOW     Base-e (natural) exponential:  *R ⍝ 1≥≡R
∆GD       Gudermannian function:  ¯3○5○R ⍝ 1≥≡R
∆AGD      Inverse Gudermannian function:  ¯5○3○R ⍝ 1≥≡R

Random values
-------------
∆GENB     Generate random bits of shape R.
∆GENC     Generate random characters of shape R.
∆GENI     Generate random 4-byte integers of shape R.
∆GENP     Generate random positive 4-byte integers of shape R.
∆ROLL     Random integers from ⍳¨R (?R) or of shape L from ⍳R (?L⍴R).

Each-based (¨)
--------------
∆RANKe    Rank each:  ↑¨⍴¨⍴¨R
∆SHAPEe   Shape each:  ⍴¨R
∆FAXe     First axis each (1 if scalar):  ↑¨(⍴¨R),¨1
∆LAXe     Last axis each (1 if scalar):  ↑¨⌽¨1,¨⍴¨R
∆NELMe    Number of elements each:  ↑¨⍴¨,¨R
∆DRe      Data representation each:  ⎕DR¨R
∆DRNe     Data representation each, negating nested:  (⎕DR¨R)ׯ1*×≡¨R
∆ENCLOSEe Enclose each (⊂[⍬]R):  ⊂¨R
∆ANYe     Flag if any ones in each (1=simple):  1∊¨R ⍝ ⎕CT=0

Outer product
-------------
∆AVFREQ   Frequency of all characters:  +/⎕AV∘.≡,R
∆ODOMETER Generalized odometer:  ⊃,↑∘.,/,R ⍝ nested array of intvecs
∆opAND    Outer product logical and:  L∘.^R ⍝ bit
∆SIGNS    Signs summary (count neg,0,pos):  +/¯1 0 1∘.=,×R ⍝ 1≥≡R
∆UTRI     L-row upper triangular mat from vec R:  R×[⎕IO+1](⍳L)∘.≤⍳⍴R

Summarization and reduction
---------------------------
∆ALL      Flag if all ones (^/,bit, ^/,1=simple):  ~0∊R∊1 ⍝ ⎕CT=0
∆ALLZ     Flag if all zeros (~∨/,bit, ^/,0=simple):  ~0∊R∊0
∆ANY      Flag if any ones:  1∊R ⍝ ⎕CT=0
∆ANYZ     Flag if any zeros:  0∊R
∆NALL     Flag if not all ones (~^/,bit, ∨/,1≠simple):  0∊R∊1 ⍝ ⎕CT=0
∆NALLZ    Flag if not all zeros (∨/,bit, ∨/,0≠simple):  0∊R∊0
∆NONE     Flag if no ones:  ~1∊R ⍝ ⎕CT=0
∆NOZ      Flag if no zeros:  ~0∊R
∆MATCH    Flag if arrays identical:  L≡R ⍝ ⎕CT=0
∆EMATCH   Flag if arrays identical (L≡R with ⎕CT=0), including ⎕DR.
∆NESTED   Flag if nested:  1<≡R
∆SIMPLE   Flag if simple:  1≥≡R
∆SIGNS    Signs summary (count neg,0,pos):  +/¯1 0 1∘.=,×R ⍝ 1≥≡R
∆HILO     Highest and lowest:  (⌈/,R),⌊/,R ⍝ ⎕DR-based if empty
∆AVG      Average items in simple R (mean):  (+/,R)÷1⌈×/⍴R
∆SUM      Sum items in simple R:  +/,R
∆SUMABS   Sum absolute values in simple R:  +/,∣R
∆SUMELOG  Sum base-e (natural) logarithms in simple R:  +/,⍟R
∆SUMRECIP Sum reciprocals in simple R:  +/,÷R
∆SUMSQAR  Sum squares in simple R:  +/,R*2
∆SUMZEQ   Number of zeros (+/,~bit, +/,0=simple):  +/,R∊0
∆SUMZNE   Number of nonzeros (+/,bit, +/,0≠simple):  +/,~R∊0
∆SSSHAPE  Number of segments in segmented string:  +/R=1↑R
∆CRC      Cyclic redundancy 32-bit check for simple R.
∆NVEC     End partition vector (flag end of runs); ⎕CT=1<≡R.
∆PVEC     Partition vector (flag start of runs); ⎕CT=1<≡R.

Zeros and nonzeros
------------------
∆ALLZ     Flag if all zeros (~∨/,bit, ^/,0=simple):  ~0∊R∊0
∆ANYZ     Flag if any zeros:  0∊R
∆NALLZ    Flag if not all zeros (∨/,bit, ∨/,0≠simple):  0∊R∊0
∆NOZ      Flag if no zeros:  ~0∊R
∆ZEQ      Flag zeros (0=simple):  R∊0
∆ZNE      Flag nonzeros (0≠simple):  ~R∊0
∆SUMZEQ   Number of zeros (+/,~bit, +/,0=simple):  +/,R∊0
∆SUMZNE   Number of nonzeros (+/,bit, +/,0≠simple):  +/,~R∊0
∆ZNDS     Indices of zeros in vector (bitvec (~R)/⍳⍴R):  (R∊0)/⍳⍴,R
∆INDS     Indices of nonzeros in vector (bitvec R/⍳⍴R):  (~R∊0)/⍳⍴,R
∆ZMAX     Higher of zero or R (zero negative items):  0⌈R ⍝ 1≥≡R
∆ZMIN     Lower of zero or R (zero positive items):  0⌊R ⍝ 1≥≡R