Enum DyadOp 

pub enum DyadOp {
    Scalar(ScalarDyad),
    Reshape,
    Take,
    Drop,
    Right,
    Left,
    Rotate,
    RotateApl {
        last: bool,
    },
    AppendLeading,
    AppendLast,
    IndexOf {
        origin: i64,
        vector_left: bool,
    },
    MemberJ,
    MemberApl,
    From,
    Match,
    NotMatch,
    GradeSelect {
        down: bool,
    },
    Copy,
    Decode,
    Encode,
    CollateGrade {
        down: bool,
        origin: i64,
    },
    TransposeJ,
    TransposeApl,
    DecodeApl,
    EncodeApl,
    Laminate,
    Link,
    Strand,
    IntervalIndex {
        offset: i64,
        closed: bool,
    },
    IndexOfLast {
        origin: i64,
    },
    MatrixDivide,
    PartitionEnclose,
    PartitionCounts,
    Squad {
        origin: i64,
        leading: bool,
    },
    SelectAxis {
        axis: usize,
        rank: usize,
        origin: i64,
    },
    Fetch,
    PolyEval,
    PolyIntegral,
    FormatSpec,
    FormatSpecJ,
    ParseNumbers,
    SequentialMachine,
    TruthTable(u8),
    ExactForm,
    Deal {
        origin: i64,
        fixed: bool,
    },
    Boolean(BoolDyad),
    Less,
    Union,
    Intersect,
    AnagramFrom,
    Permute,
    FindSeq,
    UnicodeForm,
    PrimeMeta,
    PrimeExponents,
    SymbolForm,
    Pick {
        origin: i64,
    },
    Expand,
    WriteStream,
    SparseForm,
    NotYet(&'static str),
    None,
}

Dyadic meaning of a primitive.

Variants

Scalar(ScalarDyad)

Reshape

x $ y / x ⍴ y: lay out shape x, reusing y — its ITEMS in J, its ravel in APL.

Take

x {. y / x ↑ y: per-axis take, negative from the end, overtake fills.

Drop

x }. y / x ↓ y: per-axis drop, negative from the end.

Right

y (APL ⊢).

Left

x (APL ⊣).

Rotate

x |. y: rotate axis k of y left by x[k] (negative rotates right).

RotateApl

x ⌽ y and x ⊖ y: rotate ONE axis of y — the last one when last, the leading one otherwise — by one amount per vector along it. APL’s left argument is a whole array shaped like y with that axis removed, not J’s one amount per axis.

Fields

last: bool

AppendLeading

Catenate along the LEADING axis (J ,, APL ⍪).

AppendLast

Catenate along the LAST axis (APL ,).

IndexOf

x i. y / x ⍳ y: the index in x’s items of each cell of y, or origin + #items(x) when absent. vector_left is the Dyalog dialect’s rule that the left argument must be a vector.

Fields

origin: i64

vector_left: bool

MemberJ

x e. y: is each cell of x, shaped like y’s items, an item of y?

MemberApl

x ∊ y: does each ELEMENT of x occur anywhere in y?

From

x { y: each integer atom of x selects an item of y (negative from the end).

Match

x -: y / x ≡ y: same shape and same values; never a shape error.

NotMatch

The negation of Match (APL ≢).

GradeSelect

x /: y and x : y: x’s items reordered by the grade of y’s items.

Fields

down: bool

Copy

x # y (J), x/y and x⌿y (APL): item i of y repeated x[i] times. A one-element x applies to every item.

Decode

x #. y / x ⊥ y: mixed-radix decode. A scalar x is the base for every digit; otherwise x and y have the same length.

Encode

x #: y / x ⊤ y: mixed-radix encode. The digits become the LEADING axis of the result, which is what makes one operation serve J’s per-atom #: (right rank 0) and APL’s ⊤ (right rank infinite).

CollateGrade

x ⍋ y and x ⍒ y: the items of y graded by where each of their characters sits in the collating array x.

Fields

down: bool

origin: i64

TransposeJ

x |: y: y with the named axes moved to the end. A boxed x groups axes to be run together, which is the diagonal.

TransposeApl

x ⍉ y: x says, for each axis of y, which axis of the result it becomes; a repeated destination runs those axes together.

DecodeApl

x ⊥ y on arguments of rank 2 and above: the inner product +.× over the LAST axis of x and the LEADING axis of y.

EncodeApl

x ⊤ y where x has rank 2 or more: x’s LEADING axis is the radix, and its remaining axes frame the result along with y’s.

Laminate

x ,: y: the two arguments as the items of a new leading axis.

Link

J ;: link — (<x) before y, which is taken as it is when it is already boxed and boxed when it is not.

Strand

APL vector notation: x is one more item in front of the strand y.

IntervalIndex

J x I. y / APL x ⍸ y: which interval of the ascending x each cell of y falls in. The field is what the language adds to the count of items below it: nothing in J, ⎕IO - 1 in APL.

Fields

offset: i64

closed: bool

IndexOfLast

J x i: y: where each cell of y LAST sits among the items of x.

Fields

origin: i64

MatrixDivide

J x %. y / APL x ⌹ y: the least-squares solution of y a = x.

PartitionEnclose

APL x ⊂ y: partitioned enclose — a 1 in x opens a partition, a 0 continues it, and a leading run of 0s drops those items.

PartitionCounts

Dyalog’s partitioned enclose: the left argument counts the partitions to open before each item, rather than flagging where one begins.

Squad

APL x ⌷ y: one scalar index per axis of y.

Fields

origin: i64

leading: bool

Read the index as one item per LEADING axis, so fewer items than the rank take the trailing axes whole (the Dyalog line). Otherwise there is one item per axis, all of them named.

SelectAxis

One bracket slot of APL indexing: axis axis of y selected by x. rank, when it is not zero, is the number of slots the brackets held, checked by the slot that sees the whole array.

Fields

axis: usize

rank: usize

origin: i64

Fetch

J x {:: y: follow the path x into y, opening a level a step.

PolyEval

J x p. y: the polynomial with ascending coefficients x at y. A boxed x is the multiplier ; roots form of the same polynomial.

PolyIntegral

J x p.. y: the integral of the polynomial y’s coefficients describe, with x as the constant term.

FormatSpec

APL x ⍕ y: format by specification — one width and precision per column of the last axis, or one pair for the whole argument.

FormatSpecJ

J x ": y: format by specification — one w j d complex value per column of the last axis, or one for the whole argument. A negative width asks for the exponential form; a value that does not fit its field is written as asterisks.

ParseNumbers

J x ". y: the numbers a line of text spells, with x standing in for every word that is not one.

SequentialMachine

J x ;: y: the sequential machine x describes, run over y.

TruthTable(u8)

J x m b. y: the boolean function whose truth table m numbers, on two bits for m below 16 and on every bit of two integers for m from 16 to 31.

ExactForm

J x x: y: which exact form. 1 is the rational one, 2 the pair of numerator and denominator, _1 the conversion back to a machine number, _2 the argument unchanged.

Deal

J x ? y / x ?. y and APL x ? y: deal — x distinct values from the y below origin + y.

Fields

origin: i64

fixed: bool

Boolean(BoolDyad)

J +: and *: / APL ⍱ and ⍲: the two boolean operations that have no other reading. Both arguments must be 0 or 1.

Less

J x -. y / APL x ~ y: the items of x that are not items of y.

Union

APL x ∪ y: x’s items, then y’s items that x does not already have.

Intersect

APL x ∩ y: the items of x that y also has, in x’s order.

AnagramFrom

J x A. y: y’s items under the x-th permutation of the items, the permutations counted in lexicographic order.

Permute

J x C. y: y’s items permuted by x — a direct permutation, or a boxed list of cycles.

FindSeq

J x E. y / APL x ⍷ y: 1 at each position of y where a copy of x begins.

UnicodeForm

J x u: y: which conversion — 3 and 4 take characters to codepoints, 8 and 10 take codepoints to characters.

PrimeMeta

J x p: y: which fact about primes — _1 counts the primes below y, 0 asks whether y is composite, 1 whether it is prime, and x of magnitude 4 steps to the next or previous prime.

PrimeExponents

J x q: y: the exponents of the first x primes in y, or, for __, the distinct primes over their exponents as a 2-row table.

SymbolForm

J x s:: the numbered symbol forms. 4 gives the names as a padded character table, 5 gives them as boxes.

Pick

APL x ⊃ y: pick — follow the path x into y, opening a level a step.

Fields

origin: i64

Expand

APL x \ y and x ⍀ y: expand — a 1 in x takes the next item of y, a 0 puts a fill in its place.

WriteStream

J x 1!:2 y: write x, formatted as it displays and followed by a newline, to the stream y; the value is x. Stream 2 is stdout, which the sandbox opens, and everything else is a file, which it does not.

SparseForm

J x $.: the numbered sparse forms. _1 gives the shape, the sparse axes and the sparse element boxed; 0 converts between the two storage kinds; 1 makes a new sparse array from a shape; 2 to 5 and 7 ask about the argument; 8 drops the stored entries that hold the sparse element.

NotYet(&'static str)

None

Trait Implementations

impl Clone for DyadOp

fn clone(&self) -> DyadOp

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for DyadOp

impl Debug for DyadOp

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for DyadOp

impl PartialEq for DyadOp

fn eq(&self, other: &DyadOp) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DyadOp