Vocabulary/edot

From J Wiki
Jump to: navigation, search

>> <<   Down to: Dyad   Back to: Vocabulary Thru to: Dictionary

e. y Raze In

Rank Infinity -- operates on x and y as a whole, by items of y -- WHY IS THIS IMPORTANT?



Returns a Boolean table comparing each box of y (a list of boxed atoms) against each atom in ;y (the Raze of y).

There is one row for each atom in y, and one column for each item in ;y

   ] y=: 'alpha' ; 'bravo' ; 'charlie'
+-----+-----+-------+
|alpha|bravo|charlie|
+-----+-----+-------+
   ;y
alphabravocharlie
   e.y
1 1 1 1 1 0 0 1 0 0 0 1 1 0 1 0 0
1 0 0 0 1 1 1 1 1 1 0 0 1 1 0 0 0
1 1 0 1 1 0 1 1 0 0 1 1 1 1 1 1 1

Common Uses

1. To create an n-by-n identity matrix

   e. i. 4
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

More Information

1.  e. y is identical to (;y)&e.@> y. If any of the items of y contain arrays of rank 2 or higher, the result is complicated.

2.  e. y uses tolerant comparison. Use  e.!.0 in place of  e. for exact comparison.

3. Analysis: The following expression attaches captions to (e.y) which explain it:

   2 2 $ '' ; (,' ',.~;y) ; (>y) ; (e.y)
+-------+----------------------------------+
|       |a l p h a b r a v o c h a r l i e |
+-------+----------------------------------+
|alpha  |1 1 1 1 1 0 0 1 0 0 0 1 1 0 1 0 0 |
|bravo  |1 0 0 0 1 1 1 1 1 1 0 0 1 1 0 0 0 |
|charlie|1 1 0 1 1 0 1 1 0 0 1 1 1 1 1 1 1 |
+-------+----------------------------------+

1 at the top-left denotes that the block <'alpha' contains 'a' -- and so forth.


x e. y Member (In)

Rank Infinity -- operates on x and y as a whole, by items of y -- WHY IS THIS IMPORTANT?



Returns 1 if item x is in array y, otherwise 0.

   'a' e. 'alpha'    NB. yes, the atom: 'a' is in the literal list
1
   'd' e. 'alpha'    NB. no, the atom: 'd' is NOT in 'alpha'
0
   'a' e. 1 2 3      NB. 'a' is not in the numeric list (Note: no error signalled)
0

y is treated as a list of its items, and each cell of x that has the same rank as an item of y is checked to see if it matches an item of y. The result has one atom for each such cell of x.


Common Uses

1. Test if a given atom is in a given list

   'b' e. 'abracadabra'
1
   'x' e. 'abracadabra'
0

2. Test multiple atoms at once

   'bz' e. 'abracadabra'
1 0

3. Test for the presence of certain characters in input strings

   if=: 3 : 'if. y do. ''TRUE'' else. ''FALSE'' end.'   NB. utility to test if.-conditions

   FILENAME=: '/Users/myusername/Desktop/myfile.txt'
   if +./ ('\/' e. FILENAME) do.                        NB. does FILENAME have a path?

The preferred form (see below) is '\/' +./@:e. FILENAME

4. The items can be boxes, in which case the contents must match... exactly

   ]y =. ;: 'There is a tide in the affairs of men'     NB. A boxed list
+-----+--+-+----+--+---+-------+--+---+
|There|is|a|tide|in|the|affairs|of|men|
+-----+--+-+----+--+---+-------+--+---+
   (<'the') e. y                                        NB. contains 'the'
1
   (<'a') e. y                                          NB. What? Doesn't contain <'a' ??
0
   (<,'a') e. y                                         NB. No, it contains <,'a'
1

5. The item to search for may be a list, if the search space is a table.

The entire list must match

   ] t=: >'alpha' ; 'bravo' ; 'charlie'
alpha
bravo
charlie

   $t               NB. It's 3x7, with spaces added for fill
3 7

   'alpha' e. t     NB. e. doesn't find 'alpha' because it's only part of t
0
   'alpha  ' e. t
1
   'charlie' e. t   NB. 'charlie' stretches across the whole width of t, so no need to pad it
1

More Information

1. x e. y is a member of the i.-family.

2. The internal rank of x e. y uses items whose rank is the rank of items of y.

3. If riy is the rank of an item of y, the shape of the result is  (-riy)}.$x

4. If x and y are of different types, or if their items couldn't possibly match because of differing shapes, no error is signaled: each search simply fails to match.

5. x e. y is equivalent to (#y) = y i. x.


Use These Combinations

Combinations using x e. y that have exceptionally good performance include those shown in Searching and Matching Items: Fast List Operations (FLOs) and Searching and Matching Items: Precomputed searches, as well as the following:

What it does Type;

Precisions;
Ranks

Syntax Variants;

Restrictions

Benefits;

Bug Warnings

Operations on a flattened array x ({ ,) y

x ({. ,) y
x (}. ,) y
x (e. ,) y
f/@, y
(f is any verb)

or @: & &: in place of @ Avoids copying the array to compute (,y)