Variant

Z←f⍠B R or Z←L f⍠B R evaluates f R or L f R in the context described by B.

L and R are arbitrary arrays conformable with f, and B is a simple scalar, simple or heterogeneous vector, or nested vector.

f is a function.

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

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 Key Val, or multiple properties in the form of (Key1 Val1) (Key2 Val2) ..., or if the left operand is a primitive function, a shorthand notation may be used as in Val or Val1 Val2.

In the general case, the keys specify a property such as Index Origin as 'IO' or Comparison Tolerance as 'CT', 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 'CT', 'DT', 'IO', and 'PP' which stand for the corresponding system variable.

For example:

      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

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

If the left operand is a primitive function, the following shorthands may be used:

⍳R and L⍳R	N	⎕IO←N
	N1 N2	⎕IO←N1 and ⎕CT←N2
L⌷R, L⍉R, ⍋R, L⍋R, ⍒R, L⍒R, L⊂R, ⍸R, LπR	N	⎕IO←N
⍕R and L⍕R	N	⎕PP←N
L<R, L≤R, L=R, L≠R, L≥R, L>R, L∊R, L≡R, L≢R, L∪R, L∩R, L⊆R, L⊇R, L§R, L~R, L⍷R, L|R ⌊R, ⌈R, ∪R	N	⎕CT←N
?R and L?R	N	⎕IO←N
	C	⎕DT←C
	N C	⎕IO←N and ⎕DT←C
	C N	⎕IO←N and ⎕DT←C
!R (Pochhammer k-symbol)	N	Rising (N > 0) and Falling (N < 0) factorial of length |N, stepping by |N in the direction of N
	N1 N2	Rising (N1 > 0) and Falling (N1 < 0) factorial of length |N1, stepping by |N2 in the direction of N1

Rising and Falling Factorials

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

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

Here are some examples of the falling factorial

      !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

and now falling by 2

      (!⍠¯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

and here are some examples of the rising factorial

      (!⍠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

and now rising by 2

      (!⍠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

Identities

(!⍠N)R	←→	(!⍠(N 1))R
(!⍠(N 0))R	←→	R*N

NARS 2000 Lang Tool Bar

←

→

+

-

×

÷

*

⍟

⌹

○

!

?

√

|

⌈

⌊

⊥

⊤

⊣

⊢

≡

≢

<

≤

=

≥

>

≠

∨

∧

⍱

⍲

↑

↓

⊂

⊃

⌷

⍋

⍒

⍳

∊

⍸

⍷

∪

∩

⊆

⊇

~

§

π

..

,

⍪

⍴

⌽

⊖

⍉

/

\

⌿

⍀

⊙

¨

⍨

⍤

⍣

⍡

⍥

⍦

.

∘

⍠

‼

⌻

∂

∫

⍞

⎕

⍎

⍕

⋄

⍝

∇

∆

⍙

_

⍺

⍵

¯

⍬

∞

∅

Second Row

i j k

i j k l

g

p

r

v

x