# Vocabulary/lt

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

`< y`Box

Rank Infinity *-- operates on x and y as a whole --*
WHY IS THIS IMPORTANT?

Convert the noun `y` to boxed form, by creating a box whose contents are `y`.
A box is treated as an atom and can be put into an array with other boxes, regardless of the contents of the boxes.

< 1 2 3 +-----+ |1 2 3| +-----+ < 'abc' +---+ |abc| +---+

Boxes are used to create heterogeneous arrays. Arrays in J must be rectangular, and must contain only values of the same type and precision. But if you put a noun into a box, it becomes an atom that you can array with other boxes.

Consider a list of strings of varying length: you can't make a table of varying-length strings, but you can box each string and make a list of those boxes.
Words (`;:`) does this:

;: 'Three different words' +-----+---------+-----+ |Three|different|words| +-----+---------+-----+

You might need to join dissimilar types into an array. Link (`;`) can join them by boxing them:

_2 ]\ 'front nine';36;'back nine';38 +----------+--+ |front nine|36| +----------+--+ |back nine |38| +----------+--+

### Common uses

1. To add elements to a vector of boxed strings:

]zub=: ;:'alpha bravo charlie' +-----+-----+-------+ |alpha|bravo|charlie| +-----+-----+-------+ zub,<'delta' +-----+-----+-------+-----+ |alpha|bravo|charlie|delta| +-----+-----+-------+-----+

2. To compare a string with contents of a vector of boxed strings:

zub = <'bravo' 0 1 0

3. Some primitives and Foreigns (`!:`), especially those designed to work on a boxed list of names,
demand a boxed argument if only one name is given.

xx=: yy=: zz=: 99 4!:55 'zz' NB. try to erase word: zz |domain error | 4!:55'zz' 4!:55 <'zz' NB. erase word: zz 1 4!:55 'xx' ; 'yy' 1 1

The z-locale verb: `erase`, which invokes `4!:55`, accepts either a boxed or an unboxed string.

4. The z-locale verb: `boxopen` boxes its argument, but only if unboxed or empty:

boxopen 'zz' +--+ |zz| +--+ boxopen <'zz' +--+ |zz| +--+

5. The z-locale verb: `boxxopen` boxes its argument, but only if unboxed and not empty:

boxxopen 'notempty' +--------+ |notempty| +--------+ boxxopen '' boxopen '' ++ || ++

### Related Primitives

Open (`> y`)

### Use These Combinations

Combinations using `< y` that have exceptionally good performance include:

**What it does****Type;**

**Precisions;**

Ranks**Syntax****Variants;**

**Restrictions****Benefits;**

**Bug Warnings**Box items of list `;/ y`linear time (like `<"_1 y`)Join contents of boxed items along first axis `,&.>/ y`**Bug warning:**Atomic replication is inaccurate. OK if contents of same rank. Better to use`<@; y`Extract multiple substrings into a list Boolean list, byte list `x ;@:(<;.0) y`or `[: ; <;.0`avoids boxing, avoids creating subarrays Fetch from multiple index lists (each row of `x`is one index list into`y`)`x (<"1@[ { ]) y`avoids boxing `x`Boxing intervals `<@f/;.n y`

`x <@f/;.n y`

(`f`is any verb)`n e. _2 _1 1 2`Concatenated results on intervals `;@:(<@u;.n) y``n e. _2 _1 1 2`;

also

`[: ; (<@:u;.n)`;

also`<@u;.n``x`is a**Boolean list**(**not**an atom or an integer list with values`0`or`1`)`x ;@:(<@u;.n) y`Concatenated running totals on intervals (running total, but total is reset at start of each interval) `;@:(<@(f/\);.n) y`

`x ;@:(<@(f/\);.n) y`

(`f`is any verb)`n e. _2 _1 1 2`; also`[: ; (f...`also`<@:(f/\)`; also`<@:`Box the indexes of identical items `(</. i.@#) y`

`y </. i. # y``(</. i.@#) y`uses less space

`x < y`Less Than

Rank 0 0 *-- operates on individual atoms of x and y, producing a result of the same shape --*
WHY IS THIS IMPORTANT?

Compares `x` and `y` atom-by-atom. See Equal (`=`) for the details.

Wherever `x` is greater than, or equal to, `y`, returns 1 in that position, else 0.

z=: 7 8 9 z < 8 1 0 0

`x` and `y` must both be numeric, else you get a `domain error`

'a' < 9 |domain error | 'a' <9

This differs from what happens with Equal (`=`)

'a' = 9 0

**Less Than** (`<`) uses tolerant comparison
in the same way as Equal (`=`).

To require exact comparison, use (`<!.0`) in place of (`<`) to temporarily set the comparison tolerance to zero

1.99999999999999 < 2 0 1.99999999999999 (<!.0) 2 1

### Common uses

1. Make a conditional phrase in a verb definition (explicit definition)

if. x<y do. 'x y'=. y;x end.

2. Make a mask of the same shape as `array`, to process `array` in some chosen way

array=: 3 1 4 1 5 9 2 6 mask=: array < 5 array ,: mask 3 1 4 1 5 9 2 6 1 1 1 1 0 0 1 0 mask # array NB. keep only the atoms that are < 5 3 1 4 1 2

**NOTE:**
The boolean atoms of `mask` are not only truth values but also valid numbers, 0 or 1.
Therefore you can use `mask` directly to process `array` like this:

array + 3 * mask NB. add 3 to the atoms that are < 5 6 4 7 4 5 9 5 6

### Related Primitives

Equal (`x = y`),
Not-Equal (`x ~: y`),
Larger Or Equal (`x >: y`),
Less Or Equal (`x <: y`),
Larger Than (`x > y`)

### More Information

1. If an argument to `x < y` is complex, its imaginary part must be tolerantly equal to 0, using the default tolerance of `2^_44` even if the comparison `x < y` itself uses a different tolerance.

### Performance Note

Comparisons are fastest when the precisions are identical. If an atom is compared against an array, it helps to choose the right precision for the atom.

0. < %: i. 10 NB. float list: faster than 0 < 00 < i. 10 NB. integer list: faster than 0 <

### Use These Combinations

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

**What it does****Type;**

**Precisions;**

Ranks**Syntax****Variants;**

**Restrictions****Benefits;**

**Bug Warnings**Boolean reductions along diagonals Boolean `+.//. y``*. = ~: < <: > >:`in place of`+.`avoids building argument cells