💾 Archived View for tranarchy.fish › ~autumn › apl2 › chapter5.gmi captured on 2023-04-19 at 22:49:34. Gemini links have been rewritten to link to archived content

-=-=-=-=-=-=-

Chapter 5: Working with Arrays

Chapter

<div>

</div>

<h2>Working with Arrays</h2>

In the previous chapters, you worked only with scalar and vector data. APL2 allows you to represent data organized in other ways. This chapter shows different ways of arranging data in arrays and discusses functions that create, measure, and manipulate arrays.

Before continuing with this chapter, remember to <code>)LOAD</code> your <code>LEARN</code> workspace so you’ll have access to the work you’ve done in the first four chapters. When you are finished, be sure to <code>)SAVE LEARN</code> before exiting APL2.

<h3 id="section-5.1-properties-of-arrays">Section 5.1 — Properties of Arrays<a href="#section-5.1-properties-of-arrays" class="section-link">§</a></h3>

APL2 has two types of data: numbers and characters. A collection of data is an array. An array is a rectangular arrangement of data called the items of the array. Each item is a number, a character, or another array. The number of items in an array is the count of the array.

An array that has rows and columns is sometimes called a matrix or a table, A matrix can be pictured as a rectangle:

</center>

Notice that in this rectangle, all the rows have the same length, and all the columns have the same length.

It is not the geometry that is important but rather the fact that every row of an array has the same number of items and every column in an array contains the same number of items. That is, the length of a row (or column) is the same for all rows (or columns). The term rectangular is, then, extended to collections of data organized along any number of independent directions.

The directions along which data in an array is arranged are the axes of the array. The number of directions is the rank of the array. Thus a table having rows and columns has two axes and a rank of 2. A vector (such as <code>1 2 3</code>) has one axis and a rank of 1. A single number (such as <code>3</code>) is not arranged along any axes and so has rank 0. Ranks higher than 2 are allowed up to some implementation limit (typically 64).

APL2 has special names for arrays that have rank 0, 1, or 2:

<ul>

<li>Rank 0 — Scalar</li>

<li>Rank 1 — Vector</li>

<li>Rank 2 — Matrix</li>

</ul>

You should attach no other significance to these words. Scalar means only rank 0. A single number or character must be called a simple scalar because it is possible to have a scalar whose item is a non-scalar array. Vector means only rank 1. You don’t need to know vector algebra to understand APL2 vectors (although a vector in algebra is closely related to an APL2 simple numeric vector).

Because arrays are rectangular, a simple vector of integers gives the lengths of each axis. This vector is the shape of the array. It is this vector that is returned as the result of the shape (<code>⍴</code>) function introduced in <a href="chapter2.html">Chapter 2</a>.

Arrays also have a property called depth. Depth is best understood by looking at a few examples.

Simple scalars are depth-zero arrays. Here are two depth-zero Arrays:

<pre> 2.345

'A'</pre>

Any other array that contains only items of depth 0 has a depth of 1. These two arrays have depth 1:

<pre> 2 3 4

'ABC'</pre>

An array that contains an item of depth 1 and no item of greater depth has depth 2. Here are two depth-2 arrays:

<pre> (2 3) (4 5) (6 7)

'AB' 'CD' 'XYZ'</pre>

In general, an array that contains an item of depth <math><mi>n</mi></math> and no item of greater depth, has depth <math><mi>n</mi><mo>+</mo><mn>1</mn></math> (for <math><mi>n</mi></math> not less than 0). Here’s a vector of depth <code>4</code>:

Arrays have two classifications according to depth that this book uses in later discussions:

<ul>

<li>Simple array — Array of depth 0 or 1</li>

<li>Nested array — Array of depth 2 or more</li>

</ul>

<h4 id="exercises-for-section-5.1">Exercises for Section 5.1[<a href="answers.html#section-5.1-properties-of-arrays">Answers</a>]<a href="#exercises-for-section-5.1" class="section-link">§</a></h4>

<ol>

<li>Classify the following arrays as scalar or vector:

</ol></li>

<li>Classify the following arrays as simple or nested. State the shape and the depth of each:

</ol></li>

<li>Can a scalar be an empty array?</li>

<li>Is there such a thing as a scalar that contains no data?</li>

</ol>

<h3 id="section-5.2-building-and-displaying-arrays">Section 5.2 — Building and Displaying Arrays<a href="#section-5.2-building-and-displaying-arrays" class="section-link">§</a></h3>

Using vector notation, you can construct any vector of length two or longer as long as its items are scalars or vectors of length two or longer. You cannot use vector notation to construct a one-item vector, a zero-item vector, or a matrix.

The function reshape (<code>⍴</code>), together with vector notation, can form any array. This section introduces that function and discusses the rules governing the display of arrays.

<h4 id="reshape">Reshape<a href="#reshape" class="section-link">§</a></h4>

The function reshape (<code>⍴</code>) takes the items from its right argument and forms them in the shape specified by the left argument. For example, the following expression arranges the numbers from <code>1</code> through <code>24</code> in a matrix (rank 2):

<pre> A← 4 6⍴⍳24

1 2 3 4 5 6

7 8 9 10 11 12

13 14 15 16 17 18

19 20 21 22 23 24

DISPLAY A

.→----------------.

↓ 1 2 3 4 5 6|

| 7 8 9 10 11 12|

|13 14 15 16 17 18|

|19 20 21 22 23 24|

'∼----------------'</pre>

This array has four rows and six columns. When given a matrix, <code>DISPLAY</code> puts arrows on the left edge and the top edge.

The examples use interval (<code>⍳</code>) as a convenient means of generating data, but the right argument could be any array containing any data and the discussion of reshape would remain the same. Just remember that the left argument of reshape is the shape of the desired array and the right argument is the set of values that become the items of the desired array.

The rank of the result of reshape is the length of the left argument. In the preceding example, the left argument has two integers, and so the resulting array has rank 2.

You can use reshape to form the same data into other structures as well. In the following example, reshape produces a rank-3 structure:

<pre> B←2 3 4⍴⍳24

1 2 3 4

5 6 7 8

9 10 11 12

13 14 15 16

17 18 19 20

21 22 23 24</pre>

The array <code>B</code> has two planes, three rows, and four columns. Notice that the rank-3 display is composed of two rank-2 displays which are separated by a blank row. The arrangement and spacing gives you a visual hint that the array is a rank-3 array. The result of applying <code>DISPLAY</code> to a rank-3 array has two left edges each marked with an arrow:

<pre> DISPLAY B

..→----------.

↓↓ 1 2 3 4|

|| 5 6 7 8|

|| 9 10 11 12|

||13 14 15 16|

||17 18 19 20|

||21 22 23 24|

''∼----------'</pre>

The right argument of reshape need not be a vector. APL2 ignores the structure of the right argument and uses its items in row-major order (that is, all items from row 1 are used before any items from row 2, and so on). Thus, <code>B</code> could have been defined from <code>A</code> as follows:

You form higher-rank arrays in exactly the same way. Here is the construction of a rank-4 array:

<pre> C←2 3 4 5⍴⍳120

1 2 3 4 5 ---. ---. ---.

6 7 8 9 10 | rank 2 | |

11 12 13 14 15 | | |

16 17 18 19 20 ---' | |

| |

21 22 23 24 25 ---. | |

26 27 28 29 30 | rank 2 | rank 3 |

31 32 33 34 35 | | |

36 37 38 39 40 ---' | |

| |

41 42 43 44 45 ---. | |

46 47 48 49 50 | rank 2 | |

51 52 53 54 55 | | |

56 57 58 59 60 ---' ---' |

| rank 4

61 62 63 64 65 ---. ---. |

66 67 68 69 70 | rank 2 | |

71 72 73 74 75 | | |

76 77 78 79 80 ---' | |

| |

81 82 83 84 85 ---. | |

86 87 88 89 90 | rank 2 | rank 3 |

91 92 93 94 95 | | |

96 97 98 99 100 ---' | |

| |

101 102 103 104 105 ---. | |

106 107 108 109 110 | rank 2 | |

111 112 113 114 115 | | |

116 117 118 119 120 ---' ---' ---'</pre>

Notice that the rank-4 array appears as two rank-3 arrays separated by two blank lines. Each rank-3 array appears as three rank-2 arrays separated by a blank line.

In general, in a rank-<math><mi>n</mi></math> array, its rank <math><mi>n</mi><mo>-</mo><mn>1</mn></math> parts are displayed separated by <math><mi>n</mi><mo>-</mo><mn>2</mn></math> blank lines (for <math><mi>n</mi></math> greater than 1).

In higher-rank arrays, like <code>C</code> above, the rightmost axis is called columns, the second from the rightmost axis is called rows, and the third from the right is usually called planes. The other axes are not normally given names but are sometimes collectively called hyper-planes.

It is not necessary to use all the items from the right argument in producing the result of reshape. The following expression uses only the first six items from the right argument:

<pre> D←2 3⍴A

1 2 3

4 5 6</pre>

If the right argument does not have enough items to define every item in the result, the items are used over and over again as necessary as in this example:

<pre> E←3 3⍴ 1 0 0 0

1 0 0

0 1 0

0 0 1</pre>

The 1 is used three times, and each zero is used twice.

If the right argument has only one item, it is used to define every item of the result:

<pre> F←3 3⍴0

0 0 0

0 0 0</pre>

Since reshape can use items repeatedly, you can use it to easily produce vectors of repeating values:

<pre> 9⍴ 1 2 3

1 2 3 1 2 3 1 2 3</pre>

All the examples of reshape so far have used numbers in the right argument. In fact, the right argument could contain anything and the result would be a rearrangement of those things. Here’s a hypothetical example (don’t try to enter this):

<code>G</code> will have two rows and two columns with the four items arranged like this:

<table>

<tbody>

<tr>

</tr>

<tr>

</tr>

</tbody>

</table>

</center>

Each item in the matrix is any array at all.

Here’s an example that is suitable for entry:

<pre> G←2 2⍴ A 'TWO' F (3 4)

1 2 3 4 5 6 TWO

7 8 9 10 11 12

13 14 15 16 17 18

19 20 21 22 23 24

0 0 0 3 4

0 0 0

DISPLAY G

.→--------------------------.

↓ .→----------------. .→--. |

| ↓ 1 2 3 4 5 6| |TWO| |

| | 7 8 9 10 11 12| '---' |

| |13 14 15 16 17 18| |

| |19 20 21 22 23 24| |

| '∼----------------' |

| .→----. .→--. |

| ↓0 0 0| |3 4| |

| |0 0 0| '∼--' |

| |0 0 0| |

| '∼----' |

'∊--------------------------'</pre>

The right argument is a four-item vector. The first and third items come from the variables <code>A</code> and <code>F</code> defined in earlier examples. The second and fourth items are the vectors shown. Remember that writing four arrays next to each other produces a four-item vector.

The same result could have been computed without using the variables <code>A</code> and <code>F</code> as follows:

Because you can use reshape itself to form any item in the right argument of another reshape, you can construct every possible APL2 array using the function reshape together with vector notation.

Reshape produces arrays of any rank, while vector notation can produce only arrays of rank 1. Reshape can also produce rank-1 arrays including those that vector notation cannot express—namely, vectors of length less than 2.

<pre> 1⍴5

5</pre>

This is not the scalar 5 even though it is printed the same way. It is a one-item vector containing 5 as its only item:

<pre> DISPLAY 1⍴5

.→.

|5|

'∼'</pre>

Reshape can produce a vector with no items at all:

This result is an empty vector. It is displayed on one line with no data.

An empty array may be an item of a non-empty array:

<pre> H← 2 3⍴(2 3)(⍳0)(0 5⍴0)(4 5) '' 'ABC'

2 3

4 5 ABC </pre>

Notice that the empty arrays yield spaces in the result.

<code>DISPLAY</code> puts <code>⌽</code> on the left edge if a matrix has zero rows, and <code>⊖</code> on the top edge if the matrix has zero columns:

<pre> DISPLAY H

.→----------------------.

↓ .→--. .⊖. .→--------. |

| |2 3| |0| ⌽0 0 0 0 0| |

| '∼--' '∼' '∼--------' |

| .→--. .⊖. .→--. |

| |4 5| | | |ABC| |

| '∼--' '-' '---' |

'∊----------------------'</pre>

<h4 id="default-display-of-arrays">Default Display of Arrays<a href="#default-display-of-arrays" class="section-link">§</a></h4>

You’ve seen several examples of the presentation of arrays on an output device. Basically, these presentations are rectangular arrangements of the items. Knowing the rules that govern these displays can help you interpret what you see. The rules may vary somewhat on different implementations, so check the documentation for your implementation to be sure. Here is the set of rules for the IBM APL2 implementation and some examples.

<ol>

<li>The width of a column depends only on the data in the column. Each column is only as wide as necessary. Here’s a simple array of numbers:

<pre> 1 1 1 1 1 1 1 1

2 4 8 16 32 64 128 256

3 9 27 81 243 729 2187 6561

4 16 64 256 1024 4096 16384 65536</pre></li>

<li>At least one blank separates any column containing a number from adjacent columns. Numbers are right-justified in a column on the decimal point. There is no separation between adjacent columns that contain only scalar characters. Here’s a simple 3 by 5 array where columns 1, 2, and 3 are numbers, columns 4, 5, and 6 are characters, and column 7 is a mixture of numbers and characters:

<pre> 1 2 3 DOG 5

8 19 10 CAT 7

8 7 6 MAN D</pre></li>

<li>If a column contains only character vectors or scalars, the characters are left-justified. Here’s a two-column array where column 1 has character vectors and column 2 has single numbers:

<pre> YEAR 1988

MONTH 2

DAY 23</pre></li>

<li>If a column contains character vectors and numbers, the character vectors are right-justified. Here’s an array where each item in row 1 is a four-item character vector and every other item is a number:

<pre>COL1 COL2 COL3 COL4 COLS COL6 COL7 COL8

1 1 1 1 1 1 1 1

2 4 8 16 32 64 128 256

3 9 27 81 243 729 2187 6561

4 16 64 256 1024 4096 16384 65536</pre></li>

<li>Other nested items are displayed with a leading and trailing blank for each level of nesting (depth). Here’s an example you’ve seen before:

<pre>1 2 3 4 TWO

5 6 7 8

9 10 11 12

0 0 0 3 4

0 0 0 </pre>

Three blanks separate the columns: one is the trailing blank for the nested items in column 1; one is the blank separating non-character columns; and one is the leading blank for the nested items in column 2.</li>

<li>Arrays that are wider than the output device are truncated near the right margin, then continued on subsequent lines indented six spaces. Here is a five-by-eleven numeric matrix presented on an output device 40 characters wide:

<pre>1 1 1 1 1 1 1 1

2 4 8 16 32 64 128 256

3 9 27 81 243 729 2187 6561

4 16 64 256 1024 4096 16384 65536

5 25 125 625 3125 15625 78125 390625

1 1 1

512 1024 2048

19683 59049 177147

262144 1048576 4194304

1953125 9765625 48828125</pre></li>

</ol>

Does knowing the rules for output allow you to always unambiguously deduce the properties of an array, given its display? Here’s an output. Can you determine what array it represents?

Did you guess a three-item vector of the integers 1, 2, and 3? It does look like that and it’s a good guess, but here are some expressions that produce the same output:

<pre>1 '2' 3

1 3⍴ 1 2 3

'1 2 3'</pre>

In general, you cannot be sure what you’re looking at. APL2 displays data without explicit indication of its type or structure. APL2 output is designed to display data in a pleasing form. If you need to know exactly what the value, type, and structure of an array are, you must apply functions to the data. <a href="#section-5.3-measuring-arrays">Section 5.3</a> discusses the functions you use to determine this information about an array.

<h4 id="applying-the-display-function-to-arrays">Applying the <code>DISPLAY</code> Function to Arrays<a href="#applying-the-display-function-to-arrays" class="section-link">§</a></h4>

You have seen examples of <code>DISPLAY</code> applied to all types of arrays, The following table summarizes the symbols the <code>DISPLAY</code> function uses:

<table>

<caption>Table 5.1 Summary of <code>DISPLAY</code> Symbols</caption>

<thead>

<th class="l t r b" style="text-align: center;">Placement</th>

<th class="l t r b" style="text-align: center;">Meaning</th>

</tr>

</thead>

<tbody>

<tr>

<td class="l t r">beneath a character</td>

<td class="l t r">scalar character</td>

</tr>

<tr>

<td class="l r">vector or higher-rank array</td>

</tr>

<tr>

<td class="l r">lower edge of box</td>

<td class="l r">numeric data</td>

</tr>

<tr>

<td class="l r">lower edge of box</td>

<td class="l r">mixed data</td>

</tr>

<tr>

<td class="l r">empty vector or higher-rank array</td>

</tr>

<tr>

<td class="l r">matrix or higher-rank array</td>

</tr>

<tr>

<td class="l r">empty matrix or higher-rank array</td>

</tr>

<tr>

<td class="l r b">lower edge of box</td>

<td class="l r b">nested array</td>

</tr>

</tbody>

</table>

</center>

<h4 id="exercises-for-section-5.2">Exercises for Section 5.2[<a href="answers.html#section-5.2-building-and-displaying-arrays">Answers</a>]<a href="#exercises-for-section-5.2" class="section-link">§</a></h4>

<ol>

<li>State the shape and result of the following expressions:

<li><code>2 2⍴ 'BUILT' 25 'SHIPPED' 20</code></li>

</ol></li>

<li>Write an expression whose value displays as five blank lines.</li>

<li>Create a defined function to produce <code>N</code> blank lines.</li>

<li>Given the following variables:

<pre> D ← 5 10 15 20 1 3 6 12

A ← 3 2

R ← 4

C ← 3</pre>

Write a general expression to build an array from <code>D</code> to reflect each of the following specifications:

<li>An array with as many rows as the value of <code>R</code> and as many columns as the value of <code>C</code>.</li>

<li>An array with as many rows as <code>D</code> has items and three columns.</li>

<li>An array with as many rows as 3 times the number of items in <code>D</code> and as many columns as the product of <code>R</code> and <code>C</code>.</li>

</ol></li>

<li>An identity matrix is a matrix in which every item is zero except those along the main diagonal, which are <code>1</code>’s. Here is a 3-by-3 identity matrix:

<pre> 1 0 0

0 1 0

0 0 1</pre>

Given <code>N</code>, a nonnegative scalar integer, write an expression using reshape and catenate to produce an <code>N</code>-by-<code>N</code> identity matrix.</li>

<li>Write an expression to produce a 2-by-3 array that contains no data.</li>

<li>Given non-empty array <code>AR</code>, write an expression using only reshape and vector notation to produce the following arrays:

<li>A five-item vector with each item being <code>AR</code>.</li>

<li>A vector whose items are the items of <code>AR</code>.</li>

<li>A scalar whose only item is <code>AR</code>.</li>

</ol></li>

</ol>

<h3 id="section-5.3-measuring-arrays">Section 5.3 — Measuring Arrays<a href="#section-5.3-measuring-arrays" class="section-link">§</a></h3>

This section discusses the main functions used to compute the properties of arrays: shape, rank, count, and depth.

<h4 id="shape">Shape<a href="#shape" class="section-link">§</a></h4>

You have seen shape applied to vectors and scalars. It applies to any array and returns as its result an integer vector representing the shape of the array. Here are the shapes of some of the arrays used in the examples of reshape:

<pre> A←4 6⍴⍳24

⍴A

4 6

B←2 3 4⍴⍳24

⍴B

2 3 4

C←2 3 4 5⍴⍳120

⍴C

2 3 4 5</pre>

Shape applied to an empty array produces a vector containing at least one zero:

<pre> ⍴⍳0

⍴ 0 5⍴0

0 5</pre>

The functions shape and reshape are related by the following identity:

<pre> A <--> (⍴A)⍴A for any array A</pre>

This identity says that if you reshape <code>A</code> to the shape it already has, you get the same <code>A</code> as the result.

Shape also measures the rank of an array. Because shape measures any array, it can measure the result of the application of shape itself. Thus, in the expression <code>⍴⍴A</code>, the rightmost <code>⍴</code> produces a vector containing the length of each axis. The second <code>⍴</code> counts the number of items in the length vector, and so computes the rank of an array:

<pre> ⍴⍴A

⍴⍴B

⍴⍴C

4</pre>

Remember that shape always returns a vector. Therefore, the numbers produced are one-item vectors, not simple scalars:

<pre> DISPLAY ⍴⍴A

.→.

|2|

'∼'</pre>

<h4 id="count">Count<a href="#count" class="section-link">§</a></h4>

You can compute the number of items in an array from its shape. Clearly an array of shape <code>2 3 5</code> has <code>2×3×5</code> items. A multiplication-reduction (<code>×/</code>) computes the count of an array:

<pre> ×/⍴A

×/⍴B

×/⍴C

120</pre>

In a nested array, the items of the items do not contribute to the count. Thus, the count of a two-item vector is <code>2</code> no matter how much data is in each item:

<pre> ×/⍴(1 2)(2 5⍴⍳10)

2</pre>

You use each to measure the count of each item in an array:

<pre> ×/¨⍴¨(1 2)(2 5⍴⍳10)

2 10</pre>

A scalar has one item:

<pre> ×/⍴2.345

1</pre>

<h4 id="depth">Depth<a href="#depth" class="section-link">§</a></h4>

The monadic function depth (<code>≡</code>) measures the depth of an array. Applied to a simple scalar, depth returns a zero:

<pre> ≡5

≡'X'

0</pre>

Unlike shape (<code>⍴</code>), depth (<code>≡</code>) returns a simple scalar:

<pre> DISPLAY ≡5

0</pre>

The depth of other arrays containing only simple scalars is 1:

<pre> ≡A

≡C

1</pre>

The depth of an array that contains at least one depth-1 array and no array of greater depth has depth 2:

<pre> ≡G

2</pre>

The depth of an array is easy to determine from the <code>DISPLAY</code> function output. If you draw a line from outside the display to some simple scalar, just count <code>1</code> for every box you enter and <code>¯1</code> for every box you exit. The resulting number is the depth of that scalar. The largest number you get by doing this to every simple scalar in the array is the depth of the array.

Here is the <code>DISPLAY</code> of a depth-4 array:

<pre> T←(2 2⍴'ABC' 'DE' ((1↑5)(⍳2)) 10) 'ABC'

DISPLAY T

.→-----------------------------.

| .→-------------------. .→--. |

| ↓ .→--. .→-. | |ABC| |

| | |ABC| |DE| | '---' |

| | '---' '--' | |

| | .→----------. | |

| | | .→. .→--. | 10 | |

| | | |5| |1 2<---------------------------------------

| | | '∼' '∼--' | | |

| | '∊----------' | |

| '∊-------------------' |

'∊-----------------------------'</pre>

You can see that drawing a line to the number <code>1</code> or <code>2</code> from the right (or to the number <code>5</code> from the left) will cross the most lines (four) so the array is a depth-4 array.

Note that depth (<code>≡</code>) tells you nothing about the shape or contents of an array—only the maximum depth of nesting.

<h4 id="exercises-for-section-5.3">Exercises for Section 5.3[<a href="answers.html#section-5.3-measuring-arrays">Answers</a>]<a href="#exercises-for-section-5.3" class="section-link">§</a></h4>

<ol>

<li>Give the shape, rank, count, and depth of the following arrays. Write a one-item vector <code>N</code> as <code>1⍴N</code> to distinguish it in your response from a scalar.

</ol></li>

<li>Write an expression that describes the result of shape-each (<code>⍴¨</code>) applied to each expression in exercise 1. For example, for the array <code>(1 2 3) (4 5) 6</code> write <code>(1⍴3) (1⍴2) (⍳0)</code>.</li>

<li>Create for your toolbox a monadic function <code>DISP</code> that produces the following output:

<pre> DISP ⍳¨⍳3

SHAPE: 3 DEPTH: 2 COUNT: 3

.→------------------.

| .→. .→--. .→----. |

| |1| |1 2| |1 2 3| |

| '∼' '∼--' '∼----' |

'∊------------------'</pre></li>

<li>Apply <code>DISP</code> of the previous problem to the output of the <code>DISPLAY</code> function applied to a nested array as in this example:

<pre> DISP DISPLAY ⍳¨⍳4</pre></li>

<li>Given the following variables:

<pre> A←2 3⍴⍳6

B←5

C←'APL2'

D←A B C

E←A B</pre>

State the value, shape, and depth of the result of each of these expressions:

</ol></li>

</ol>

<h3 id="section-5.4-unshaping-and-nested-shaping-of-arrays">Section 5.4 — Unshaping and Nested Shaping of Arrays<a href="#section-5.4-unshaping-and-nested-shaping-of-arrays" class="section-link">§</a></h3>

Ravel and enlist are functions that ignore structure and rearrange their arguments into vectors. Enclose and disclose are functions that change the depth of arrays.

<h4 id="ravel">Ravel<a href="#ravel" class="section-link">§</a></h4>

The monadic function ravel might be compared to unraveling a ball of string. The items of its argument are simply arranged in a vector. Because all the items of the arguments are kept intact, the result of ravel preserves the count of the argument. Except when applied to a scalar, ravel also preserves depth. The rank of the result is always 1. Here is an example:

<pre> B←2 3 4⍴⍳24

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

20 21 22 23 24

⍴,B

G←2 2⍴ (4 6⍴⍳24) 'TWO' (3 3⍴0) (3 4)

1 2 3 4 5 6 TWO 0 0 0 3 4

7 8 9 10 11 12 0 0 0

13 14 15 16 17 18 0 0 0

13 20 21 22 23 24

⍴,G

⍴⍴,G

1</pre>

Ravel does not drop or add items to an array—it merely rearranges items into a vector. If an item of the argument is empty, it appears empty in the result:

<pre> H← 2 3⍴(2 3)(⍳0)(0 5⍴0)(4 5) '' 'ABC'

2 3 4 5 ABC

DISPLAY ,H

.→--------------------------------------.

| .→--. .⊖. .→--------. .→--. .⊖. .→--. |

| |2 3| |0| ⌽0 0 0 0 0| |4 5| | | |ABC| |

| '∼--' '∼' '∼--------' '∼--' '-' '---' |

'∊--------------------------------------'</pre>

Ravel is related to reshape by the following identity:

<pre> ,A <--> (×/⍴A)⍴A for any array A</pre>

Recall that <code>×/⍴A</code> computes the count of items in an array. A single number as the left argument of reshape specifies the creation of a vector of that length. Ravel, like reshape, is often used to overcome a limitation of vector notation. Vector notation cannot express a vector of length less than 2. Whereas <code>2 3</code> is a two-item vector, <code>2</code> is not a one-item vector. It is a simple scalar. To produce a one-item vector from a simple scalar, you can enter either of the following equivalent expressions:

<pre> ,2

1⍴2

2</pre>

<h4 id="enlist">Enlist<a href="#enlist" class="section-link">§</a></h4>

The monadic function enlist (<code>∊</code>) produces a vector but does not preserve any of the array’s properties—rank, rank, shape, depth, or count. Enlist always returns a simple vector that contains every simple scalar contained anywhere in the array. Here’s an example:

<pre> G←2 2⍴ (4 6⍴⍳24) 'TWO' (3 3⍴0) (3 4)

∊G

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

20 21 22 23 24 TWO 0 0 0 0 0 0 0 0 0 3 4

⍴∊G

38</pre>

Notice that items in the result are selected in row-major order. Every simple scalar in the first item is listed before any scalar in the following items.

If the argument to enlist contains empty items, they do not contribute to the result:

<pre> H← 2 3⍴(2 3)(⍳0)(0 5⍴0)(4 5) '' 'ABC'

∊H

2 3 4 5 ABC

⍴∊H

DISPLAY ∊H

.→----------.

|2 3 4 5 ABC|

'+----------'</pre>

If the argument to enlist is a simple array, the result is the same as ravel:

<pre> ,S <--> ∊S for simple array S</pre>

<h4 id="nested-reshaping-of-an-array-enclose">Nested Reshaping of an Array: Enclose<a href="#nested-reshaping-of-an-array-enclose" class="section-link">§</a></h4>

Reshape (<code>⍴</code>) merely rearranges the items of its argument, possibly repeating some of them. Depth is only increased when a scalar is reshaped into a non-scalar. If not all the items from the right argument are used in the result, the depth of the result might be less than the depth of the argument:

<pre> ≡ 1 2 'ABC'

≡ 2⍴1 2 'ABC'

1</pre>

The monadic function enclose (<code>⊂</code>), like reshape, only rearranges data in an array; but, except for simple scalars, it does produce a result whose depth is one greater than the depth of its argument. The enclose of a simple scalar is the simple scalar. Its depth does not change.

Enclose has only one purpose: the production of scalars. Given an array, enclose produces the scalar that contains that array as its only item. Whenever you see the enclose function, think of scalars.

The rank of the result of enclose is always zero—that is. enclose always produces a scalar. The following identity expresses this fact:

Whenever you are not interested in the array’s structure, you can use enclose to turn that array into a scalar. For example, if you are writing an application that deals with people’s names, the fact that the name Shakespeare contains 11 characters may be of no interest.

<pre> ⍴'SHAKESPEARE'

11</pre>

By enclosing the 11-character vector, you may treat the resulting scalar as a unit of data within the application.

<pre> ⍴⊂'SHAKESPEARE'

<---(empty vector)</pre>

In <a href="chapter2.html">Chapter 2</a>, you saw that the following expression catenates three new names onto a vector of names:

<pre>WHAT←⍳0

WHAT←WHAT,'LPS' 'TAPES' 'CDS'</pre>

This expression added three items onto <code>WHAT</code> because the right argument of catenate is a three-item vector. Suppose you want to append one more item to the vector: the character string <code>'VIDEOTAPE'</code>. You might be tempted to write the following (don’t do it):

<pre> WHAT←WHAT,'VIDEOTAPES'</pre>

If you wrote that expression, the right argument to catenate would be a ten-item vector and you would append ten letters—not what you want to do. You really want to append one name. Use enclose to make the nine-item vector into a scalar with one item:

<pre> WHAT←WHAT,⊂'VIDEOTAPES'</pre>

Now you’ve appended one name to the list <code>WHAT</code>:

<pre> WHAT

LPS TAPES CDS VIDEOTAPES</pre>

Note: IBM’s APL2 Release 3 adds a dyadic function partition, which is related to enclose. For information on this new function, see <a href="appendixF.html">Appendix F</a>.

<h4 id="nested-reshaping-of-an-array-disclose">Nested Reshaping of an Array: Disclose<a href="#nested-reshaping-of-an-array-disclose" class="section-link">§</a></h4>

The monadic function disclose in its simplest form undoes what enclose does. Given a scalar argument, disclose produces the array that is the only item of the scalar:

<pre> SX←⊂2 3⍴⍳6

⊃SX

1 2 3

4 5 6</pre>

The following relationship is always true between enclose and disclose:

But disclose does more than undo the result of enclose. For example, disclose can turn a nested vector into a matrix, with one row per product and one column per type of information.

Earlier you worked with this vector:

<pre> PRD←('LPS' 6.95)('TAPES' 7.95)('CDS' 12.95)

PRD

LPS 6.95 TAPES 7.95 CDS 12.95</pre>

This structure is a depth-3 array that contains one item per product. Each product item contains two fields: one for the product name and one for product cost. Disclose turns this vector into a matrix with each item providing data for one row:

<pre> PRDTBL←⊃PRD

PRDTBL

LPS 6.95

TAPES 7.95

CDS 12.95</pre>

This result is a depth-2 array with one row per product:

<pre> ⍴PRDTBL

3 2</pre>

<h4 id="exercises-for-section-5.4">Exercises for Section 5.4[<a href="answers.html#section-5.4-unshaping-and-nested-shaping-of-arrays">Answers</a>]<a href="#exercises-for-section-5.4" class="section-link">§</a></h4>

<ol>

<li>State the shape and depth of the results of following expressions:

</ol></li>

<li>Given the variables:

<pre> A← 3 4⍴⍳12

B← 3

C← 'APL'

D← A B C</pre>

State the shape and depth of the result of each of the following expressions:

</ol></li>

<li>Write a three-item vector whose enlist is empty.</li>

<li>Write an expression to construct a 2-by-3 matrix. Each item should be the name <code>'RAY'</code>.</li>

<li>Given a simple vector of non-negative integers, write an expression to produce a horizontal bar chart. For example, from <code>V←4 1 3 0 2</code>, the expression should produce the following simple character matrix:

<pre>⎕⎕⎕⎕

⎕

⎕⎕⎕

⎕⎕</pre></li>

<li>Write an expression that replaces the second item of the vector <code>V</code> with the matrix <code>M</code>.</li>

<li>Let <code>VV</code> be a vector of words like the following:

<pre> VV←'DISTRIBUTION' 'OF' 'SCORES'</pre>

Write an expression that returns a simple character vector containing the words separated by a single blank. For the example <code>VV</code>, this result is

<pre> 'DISTRIBUTION OF SCORES '</pre></li>

</ol>

<h3 id="section-5.5-manipulating-an-array-along-an-axis">Section 5.5 — Manipulating an Array along an Axis<a href="#section-5.5-manipulating-an-array-along-an-axis" class="section-link">§</a></h3>

One source of APL2’s power is the fact that the primitive operations apply to whole arrays at one time. Sometimes it is useful to think of arrays as split apart in some organized way so you can apply a function to each of the pieces. For example, a matrix can be split up in the following two ways. You can split the matrix into vectors along axis 1:

</center>

You can split the matrix into vectors along axis 2:

</center>

Similarly, a rank-3 array can be split into vectors three ways: along each of its three axes.

Many APL2 primitives allow specification of an axis to indicate the type of split. The axis is specified in square brackets on the right of the function. For example, <code>↑[1]</code> indicates a take along the first axis.

Some dyadic functions with axis split both of their arguments, while others split only one of their arguments.

Here is a general outline of how functions with axis form their result:

<ol>

<li>Split the appropriate arguments along the axis specified.</li>

<li>Apply the function (as defined without an axis) to each piece.</li>

<li>Put the resulting pieces back together again in some appropriate way.</li>

</ol>

The description of the function will tell you which arguments are split and how the pieces are put back together.

The best way to understand how functions with axis operate is to understand the relationship between the shape of the arguments and the shape of the result. The shape of the result is the same as the shape of an argument, with the exception of the axes specified. Those axes may be longer or shorter than the corresponding axes in the argument. The specified axes may not appear in the result at all or new axes may appear.

If you don’t specify an axis for a primitive, one of three defaults applies:

<ul>

<li>Function applies along the rightmost axis.</li>

<li>Function applies along the leftmost axis.</li>

<li>Function applies to all axes.</li>

</ul>

The default taken is also part of the description of each function.

The following sections discuss seven operations that allow an axis specification:

<ul>

<li>catenate</li>

<li>ravel</li>

<li>reduction</li>

<li>enclose</li>

<li>disclose</li>

</ul>

You have worked with these operations before, so the discussions concentrate on their use with axis specification.

You apply take and drop to arrays of rank 2 or greater by specifying the axis along which the vector definition is to apply. Here is an example:

<pre> A← 4 6⍴⍳24

1 2 3 4 5 6

7 8 9 10 11 12

13 14 15 16 17 18

19 20 21 22 23 24

3↑[1] A

1 2 3 4 5 6

7 8 9 10 11 12

13 14 15 16 17 18</pre>

Here is the analysis of this example using the general outline for functions with axis specification. Given the original four-by-six array:

</center>

<ul>

<li>Split the appropriate arguments along the axis specified.

Take splits the right argument as shown here:

</center>

(Note that these pictures are not using the <code>DISPLAY</code> function.) The four-by-six matrix is split into six four-item vectors. The vectors are drawn vertically to show the orientation of the axis that was split.</li>

<li>Apply the function without an axis to each piece:

</center>

The vector definition of take is applied to each of the four-item vectors, producing a set of three-item vectors.</li>

<li>Put the resulting pieces back together again in some appropriate way:

</center>

The six three-item vectors are reassembled into a three-by-six matrix.</li>

</ul>

Notice that axis 2 (the one not specified in square brackets) has the same length as before. Axis 1 (the one specified in square brackets) is shorter.

You should be able to apply the same analysis to the following example:

<pre> 3↓[2] A

4 5 6

10 11 12

16 17 18

22 23 24</pre>

Notice again, the axis specified in brackets changes length and the axis not specified stays the same length.

If more than one axis is specified, APL2 applies the function independently along each axis:

<pre> W←3 4 2⍴⍳24

2 3↑[1 2] W

1 2

3 4

5 6

9 10

11 12

13 14</pre>

Because APL2 applies the function independently along each axis, the following is an equivalent expression:

<pre> 2↑[1] 3↑[2] W

1 2

3 4

5 6

9 10

11 12

13 14</pre>

If no axis is specified, all axes are implied and the left argument must have as many items as there are axes in the right argument:

<pre> A←4 6⍴⍳24

2 3↑A

1 2 3

7 8 9</pre>

Take and drop allow no scalar extension on the left argument.

<h4 id="catenate-with-axis">Catenate with Axis<a href="#catenate-with-axis" class="section-link">§</a></h4>

Catenate can be used to join data to an array much as it attaches data to a vector. With catenate, the axis mentioned is one that will get longer as a result of the operation. For example, here’s a - catenate with axis that joins two matrices along the first axis.

<pre> A← 2 3⍴⍳6

B←4 3⍴−⍳12

A,[1]B

1 2 3

4 5 6

¯1 ¯2 ¯3

¯4 ¯5 ¯6

¯7 ¯8 ¯9

¯10 ¯11 ¯12

⍴A,[1]B

6 3</pre>

Notice that axis 2 (the one not specified in square brackets) has the same length as before. Axis 1 (the one specified in square brackets) is longer.

When both arguments have the same rank, catenate splits both arguments along the specified axis, joins corresponding vectors together, and reassembles the result. Even when the arguments are higher-rank arrays, the splitting of the arguments ends up with vectors which are joined by catenate.

You may also join an array with another array whose rank is one less. When the ranks of the arguments differ by one, catenate splits the argument of higher-rank and each vector so formed is joined with the corresponding scalar from the lower-rank argument. For example, here’s a catenate that adds a new row to the top of the <code>PRDTBL</code> matrix:

<pre> PRDTBL

LPS 6.95

TAPES 7.95

CDS 12.95

PRDTBL←'PRODUCT' 'COST',[1] PRDTBL

PRDTBL

PRODUCT COST

LPS 6.95

TAPES 7.95

CDS 12.95</pre>

In this case, the axis specified is one longer in the result.

If the music store decides that it should keep track of a third piece of information, it can add another column to the matrix. Suppose that, in addition to product name and cost, the store wants to keep track of the number of each item in its stock. The following expression adds this third column to the matrix:

<pre> PRDTBL←PRDTBL,[2] 'STOCK' 1250 1375 495

PRDTBL

PRODUCT COST STOCK

LPS 6.95 1250

TAPES 7.95 1375

CDS 12.95 495</pre>

If no axis is specified, catenate applies along the rightmost axis and, in the case of a matrix, adds new columns. If an axis is specified, it can contain only one number.

If one argument to catenate is a scalar, the non-scalar array is split along the specified axis, and the scalar is joined to each vector so formed:

<pre> (3 4⍴⍳12),1000

1 2 3 4 1000

5 6 7 8 1000

9 10 11 12 1000</pre>

Unlike most other functions with axis, catenate allows a fractional axis to indicate creation of a new axis of length 2. Catenate, when written with a fractional axis, is called laminate. For example, two vectors may be catenated as follows to form the rows or columns of a matrix:

<pre> 'ABCD',[.5] 1 2 3 4

A B C D

1 2 3 4

'ABCD',[1.5] 1 2 3 4

A 1

B 2

C 3

D 4</pre>

In the first case, a new axis of length 2 is inserted before axis 1 of the vector, giving a 2 4 array. In the second case, the new axis is added after axis 1, giving a 4 2 array.

Laminate can build a matrix from a set of equal length vectors. For example, suppose you have the following three vectors:

<pre> WHAT←'LPS' 'TAPES' 'CDS'

DISCOUNT←.9 .9 1

RETAIL←6.95 7.95 12.95</pre>

They describe the names of various possible purchases, applicable discounts, and retail prices. To keep this data under one name, use laminate:

<pre> PURCHASES← WHAT,DISCOUNT,[1.5]RETAIL

PURCHASES

LPS .9 6.95

TAPES .9 7.95

CDS 1 12.95</pre>

The rightmost axis is fractional, causing the two vectors <code>DISCOUNT</code> and <code>RETAIL</code> to be joined into a two-column matrix. Then <code>WHAT</code> is attached as a new column, giving a three-column matrix.

Keeping the data as a matrix is, in fact, a better representation than keeping three separate variables. By using a matrix, you have only one name to keep track of instead of three, and there is no chance that the values can get out of sync (some longer than others). For instance, if you ever discovered that <code>WHAT</code> had five items but <code>RETAIL</code> had six items, you wouldn’t know how to line up the corresponding items. In a matrix, it is impossible for one column to be shorter than the others.

Instead of catenating new values to each of three variables, you can catenate a new row to the matrix:

<pre> PURCHASES←PURCHASES,[1] 'VIDEODISCS' 1 19

PURCHASES

LPS .9 6.95

TAPES .9 7.95

CDS 1 12.95

VIDEODISCS 1 19</pre>

In writing an application to maintain the matrix, you would initialize the matrix to have zero rows but three columns:

<pre> PURCHASES←0 3⍴0</pre>

This makes <code>PURCHASES</code> a 0-by-3 matrix of numbers. Because there is no data, it doesn’t matter if you make the empty matrix numeric or character. Each time a new product comes along, you catenate the data for it onto the matrix. This catenate works even for the first product.

<h4 id="ravel-with-axis">Ravel with Axis<a href="#ravel-with-axis" class="section-link">§</a></h4>

As seen earlier, ravel without an axis turns any array into a vector of its items. It combines all the axes from an array to produce one long vector. Ravel with axis selects a set of adjacent axes that are combined:

<pre> B← 2 3 4⍴⍳24

,[2 3]B

1 2 3 4 5 6 7 8 9 10 11 12

13 14 15 16 17 18 19 20 21 22 23 24

⍴,[2 3]B

2 12</pre>

Ravel splits its argument along all the axes specified. In the preceding example, two axes are specified, so ravel splits the rank-3 array into matrices. Each matrix is raveled and the resulting vector shape appears in the result shape in place of the whole set of axes.

The following picture shows how the shape of the result for the example is formed:

</center>

Thus, the result is a vector if all axes are specified; a matrix if one axis is not specified; a rank-3 array if two axes are not specified; and so forth for higher-rank arrays.

There is a useful special case of ravel with axis. If the axis is empty, a new axis of length 1 is appended on the right.

If you have a long vector that is too wide to fit on your display device, you can use <code>,[⍳0]</code> to turn it into a one-column matrix. A one-column matrix displays vertically instead of horizontally:

<pre> NAMES←'JANE' 'JIM' 'EV' 'MIKE'

,[⍳0] NAMES

JANE

JIM

MIKE

⍴,[⍳0] NAMES

4 1</pre>

Like laminate, ravel with axis can take a fractional axis specification to create a new axis of length 1. For example, a vector can become a matrix with either one row or one column:

<pre> ,[.5] 'RAY' 'SANDY' 'JIM'

RAY SANDY JIM

⍴,[.5] 'RAY' 'SANDY' 'JIM'

1 3

,[1.5] '"RAY' 'SANDY' 'JIM'

RAY

SANDY

JIM

⍴,[1.5] 'RAY' 'SANDY' 'JIM'

3 1</pre>

<h4 id="reduction-with-axis">Reduction with Axis<a href="#reduction-with-axis" class="section-link">§</a></h4>

You’ve seen many applications of reduction: adding up a vector of numbers (<code>+/V</code>), computing the number of items in an array (<code>×/⍴A</code>), and so forth. In each of these applications, reduction applied to vectors and produced scalars. Reduction applies to other arrays as well—with axis specification. Axis specification, when used with reduction-derived functions, determines how to split an array into vectors. Given a matrix, the vectors could come from splitting the rows or the columns.

<pre> +/[1] 3 4⍴⍳12

15 18 21 24

⍴+/[1] 3 4⍴⍳12

+/[2] 3 4 ⍴⍳12

10 26 42

⍴+/[2] 3 4 ⍴⍳12

3</pre>

Reduction splits the array along the specified axis and reduces each vector. Since reduction of a vector always returns a scalar, each result is a scalar. Reassembling the pieces into the result produces an array with rank one less than the argument. The axes not specified in square brackets appear in the result unchanged; the axis specified does not appear in the result at all.

Reduction without an axis, by default, applies to the rightmost axis.

<pre> +/3 4⍴⍳12

10 26 42</pre>

If an axis is specified, it can contain only one number.

Instead of specifying reduction on the first axis as <code>/[1]</code>, APL2 permits the alternative symbol <code>⌿</code>:

<pre> +⌿3 4⍴⍳12

15 18 21 24</pre>

<h4 id="enclose-with-axis">Enclose with Axis<a href="#enclose-with-axis" class="section-link">§</a></h4>

Given a matrix, enclose with axis produces a vector whose items come from either the rows or the columns of its argument:

<pre> D←2 3⍴⍳6

1 2 3

4 5 6

⊂[2] D

1 2 3 4 5 6

DISPLAY ⊂[2] D

.→----------------.

| .→----. .→----. |

| |1 2 3| |4 5 6| |

| '∼----' '∼----' |

'∊----------------'

⍴⊂[2] D

2</pre>

In the preceding example, each row of the matrix becomes a vector in the result. The 2 which is the row length of <code>D</code> becomes the shape of the items of the result:

<pre> ⍴¨⊂[2] D

3 3</pre>

Enclose with axis splits its argument along the axes specified just like ravel with axis does. Each piece is enclosed, giving a scalar. Just as in reduction with axis, reassembling the scalars into the result array gives a result that does not contain the axis specified in the square brackets.

Enclose with axis applied along axis 1 of a matrix produces a vector whose items come from the columns of the argument array:

<pre> ⊂[1]D

1 4 2 5 3 6

DISPLAY ⊂[1]D

.→------------------.

| .→--. .→--. .→--. |

| |1 4| |2 5| |3 6| |

| '∼--' '∼--' '∼--' |

'∊------------------'

⍴⊂[1]D

3</pre>

You can enclose along more than one axis at a time:

<pre> H←2 4 3⍴⍳24

⊂[1 3]H

1 2 3 4 5 6 7 8 9 10 11 12

13 14 15 16 17 18 19 20 21 22 23 24

⍴⊂[1 3]H

⍴¨⊂[1 3]H

2 3 2 3 2 3 2 3</pre>

Enclose along all axes of an array is the same as enclose with no axis:

<pre> ⊂[1 2 3]H

1 2 3

4 5 6

7 8 9

10 11 17

13 14 15

16 17 18

19 20 21

22 23 24

⍴⊂[1 2 3]H

</pre>

In most cases, enclose with axis produces a result with smaller rank and greater depth that its argument. Only an empty axis specification produces a result with the same rank as the argument:

<pre> ⊂[⍳0] (1 2) (3 4 5)

1 2 3 4 5

⍴⊂[⍳0] (1 2) (3 4 5)

≡⊂[⍳0] (1 2) (3 4 5)

DISPLAY ⊂[⍳0] (1 2) (3 4 5)

.→----------------------.

| .-------. .---------. |

| | .→--. | | .→----. | |

| | |1 2| | | |3 4 5| | |

| | '∼--' | | '∼----' | |

| '∊------' '∊--------' |

'∊----------------------'</pre>

Enclose with an empty axis is the same as enclose-each.

<h4 id="disclose-with-axis">Disclose with Axis<a href="#disclose-with-axis" class="section-link">§</a></h4>

Given a vector of vectors, disclose with axis (<code>⊃[]</code>) produces a matrix whose rows or columns come from the items of the vector. Unlike other functions with axis, the numbers in brackets refer to the result axes, not the argument axes. Disclose with axis does not split its argument. It only does the rearranging with the axis specification saying where in the result new axes are inserted. Here is an example:

<pre> ⊃[1] 'FRED' 'JOHN' 'PAUL'

FJP

ROA

EHU

DNL

⍴⊃[1] 'FRED' 'JOHN' 'PAUL'

4 3

⊃[2] 'FRED' 'JOHN' 'PAUL'

FRED

JOHN

PAUL

⍴⊃[2] 'FRED' 'JOHN' 'PAUL'

3 4</pre>

Notice that disclose reduces the depth of its argument if the depth is at least 2 to start with:

<pre> ≡ 'FRED' 'JOHN' 'PAUL'

≡ ⊃[2]'FRED' 'JOHN' 'PAUL'

1</pre>

The default axis for disclose is the rightmost axis, so the second example gives the same result if the <code>[2]</code> is left off:

<pre> ⊃ 'FRED' 'JOHN' 'PAUL'

FRED

JOHN

PAUL</pre>

Unlike enclose with axis, disclose with axis can cause data to be added to an array. If the items of the argument are not the same length, they are padded on the right to the length of the longest:

<pre> ⊃[2]'FRED' 'RALPH' 'EV'

FRED

RALPH

⍴⊃[2]'FRED' 'RALPH' 'EV'

3 5</pre>

You can’t see the padding blanks but they are there. Here’s an example, using numbers, where the padding with zeros is obvious:

<pre> ⊃[2] (10 20 30 40)(⍳5)(8 7)

10 20 30 40 0

1 2 3 4 5

8 7 0 0 0</pre>

If some items are numeric and others are character, APL2 pads the numeric arrays with zeros and the character arrays with blanks:

<pre> ⊃[2] (10 20 30 40)(⍳5) 'AB'

10 20 30 40 0

1 2 3 4 5

A B </pre>

If the rank of each item is 2, then two numbers must be given as axes because two of the result axes come from the shapes of the argument items:

<pre> ⊃[1 3](2 2⍴⍳4) (3 4⍴⍳12)

1 2 0 0

1 2 3 4

3 4 0 0

5 6 7 8

0 0 0 0

9 10 11 12</pre>

The axes numbers determine where in the result shape the shapes from the items are placed:

<pre> ⍴⊃[1 3](2 2⍴⍳4) (3 4⍴⍳12)

3 2 4</pre>

The following picture shows how the shape of the result is constructed:

</center>

A scalar item is treated as a one-item array of the proper rank:

<pre> ⊃[2] (10 20 30 40)(5) 'AB'

10 20 30 40

5 0 0 0

A B</pre>

If the wrong number of axes is specified, an <code>AXIS ERROR</code> is generated:

<pre> ⊃[2 3](10 20 30 40)(⍳5)

AXIS ERROR

⊃[2 3](10 20 30 40)(⍳5)

^</pre>

If the items do not have the same rank, a <code>RANK ERROR</code> is generated:

<pre> ⊃[1] (10 20 30 40)(2 3⍴⍳6)

RANK ERROR

⊃[1] (10 20 30 40)(2 3⍴⍳6)

∧</pre>

Recall that the function disclose (<code>⊃</code>) is closely related to enclose. Whatever enclose does, disclose undoes it:

The same is true for enclose with axis and disclose with axis.

Here’s an example:

<pre> A←4 6⍴⍳24

⊃[1]⊂[1] A

1 2 3 4 5 6

7 8 9 10 11 12

13 14 15 16 17 18

19 20 21 22 23 24</pre>

<h4 id="scalar-functions-with-axis">Scalar Functions with Axis<a href="#scalar-functions-with-axis" class="section-link">§</a></h4>

When used with an axis specification, the scalar functions split the array of higher-rank along the specified axes, then apply the whole array of lower rank to each of the pieces. For example, you can add a three-item vector to each row of a four-by-three array as follows:

<pre> 10 20 30 +[2] 4 3⍴⍳6

11 22 33

14 25 36

11 22 33

14 25 36</pre>

The matrix is split along the second axis, giving four three-item vectors which are then added to the three-item vector which is the other argument.

In the same manner, you can add a vector to each column of a matrix:

<pre> 10 20 30 40 +[1] 4 3⍴⍳6

11 12 13

24 25 26

31 32 33

44 45 46</pre>

The number of axes specified matches the difference in their ranks of the arguments. A scalar may be applied to each item of a matrix by specifying both axes:

<pre> 10+[1 2] 4 3⍴⍳6

11 12 13

14 15 16

11 12 13

14 15 16</pre>

Thus in the limiting case of scalars, a scalar function with axis reduces to ordinary scalar extension.

<h4 id="exercises-for-section-5.5">Exercises for Section 5.5[<a href="answers.html#section-5.5-manipulating-an-array-along-an-axis">Answers</a>]<a href="#exercises-for-section-5.5" class="section-link">§</a></h4>

In problems 1 through 5, assume that <code>I</code>, <code>J</code>, <code>K</code>, <code>L</code>, <code>M</code>, and <code>N</code> are non-negative scalar integers and <code>A</code> is a simple array.

<ol>

<li>State the shape, rank, and depth of the results of the following expressions. Also give the shape of the items of the result. Indicate an error if one would occur:

</ol></li>

<li>State the shape, rank, and depth of the results of the following expressions. Indicate an error if one would occur:

</ol></li>

<li>State the shape, rank, and depth of the results of the following expressions. Indicate an error if one would occur:

</ol></li>

<li>State the shape of the result of the following expressions, where <code>F</code> is any dyadic function and <code>A</code> is any array:

</ol></li>

<li>State the shape of the result of the following expressions:

</ol></li>

<li>You saw that the following identity is true:

Give an example that shows that the following identity is not true:

<li>Suppose you have the following two arrays:

<pre> M←3 4⍴⍳12

A←3 4 2⍴−⍳24</pre>

Determine the value and shape of the following expressions:

</ol></li>

<li>Write an expression to extract the following:

<li>The last row of a rank-2 array <code>M</code>.</li>

<li>The first column of a rank-2 array <code>M</code>.</li>

<li>The last plane of a rank-3 array <code>M</code>.</li>

<li>The last row of the last plane of a rank-3 array <code>M</code>.</li>

<li>The first two items in the last row of the last plane of a rank-3 array <code>M</code>.</li>

</ol></li>

<li>Let <code>A</code> be defined as follows:

<pre> A←3 4⍴'ABCDEFGHIJKL'</pre>

State the result, shape, and depth of the following expressions:

</ol></li>

<li>Given the following arrays:

<pre> V←10 20 30

M←4 3⍴⍳12

N←3 3⍴⍳9

A←2 4 3 ⍴100×⍳24</pre>

Determine the value and shape of the following expressions:

</ol></li>

<li>Given variable <code>M</code>, which is either a character matrix or a vector of character vectors, write an expression to produce a vector of character vectors.</li>

<li>Given a vector of vectors where each of the items is a vector of the same length:

Write an expression to create another vector of vectors where the first item contains the first items of the original vector; the second item contains the second items of the original vector; and so on. With <code>D</code> as just defined, your expression should produce the following:

<li>Given the following variables:

<pre>TITLE←'NAME' 'PRICE' 'QUANTITY'

DATA←3 3⍴'OX' 3.95 35 'ANT' 10 100 'PIG' 45.5 13</pre>

The following expression displays a small report:

<pre> TITLE,[1]DATA

NAME PRICE QUANTITY

0X 3.95 35

ANT 10 100

PIG 45.5 13</pre>

How would you modify the preceding expression if you wanted each column to be at least 10 positions wide?</li>

<li>Write a function <code>APPEND</code> which, given a matrix, a scalar, and an integer, catenates the scalar onto the matrix on the front of and on the back of the axis indicated by the integer. Here is an example:

<pre> M←2 3 ⍴⍳6

1 2 3

4 5 6

APPEND M '|' 2

| 1 2 3 |

| 4 5 6 |</pre></li>

<li>Suppose you have a numeric matrix <code>GRADES</code> that reflects the grades a set of students earned on a series of quizzes and examinations:

<pre> GRADES

90 93 89

81 89 90

88 90 89

145 160 150

120 121 125</pre>

You really want to see the data displayed with row and column titles as follows:

<pre> J. SMITH D. BROWN R. WHITE

QUIZ 1 90 93 89

QUIZ 2 81 89 90

MIDTERM 88 90 89

PROJECT 145 160 150

FINAL 120 121 125</pre>

Define a function <code>REPORT</code> that takes as right argument the numeric matrix and as left argument the row and column titles and returns the report (like the one shown) as an explicit result.</li>

<li>Write an expression to multiply each row of matrix <code>M</code> by the corresponding item in vector <code>V</code>.</li>

<li>Define a dyadic function <code>CALENDAR</code> to return a matrix that displays like a traditional calendar. Inputs to the function should be as follows:

<ul>

<li>A left argument indicating the starting day of the week (<code>0</code>=Sunday, <code>1</code>=Monday, … <code>6</code>=Saturday).</li>

<li>An integer right argument indicating the number of days in the month.</li>

</ul>

Sample execution:

<pre> 3 CALENDAR 31

S M T W T F S

1 2 3 4

5 6 7 8 9 10 11

12 13 14 15 16 17 18

19 20 21 22 23 24 25

26 27 28 29 30 31</pre></li>

<li>Given numeric matrix <code>M</code> and numeric vector <code>V</code>, where <code>(⍴V)=¯1↑⍴M</code>, write an expression that gives the value of <code>M</code> with no value in any column greater than the corresponding item in <code>V</code>.</li>

</ol>

<h3 id="section-5.6-other-functions-on-higher-rank-arrays">Section 5.6 — Other Functions on Higher-Rank Arrays<a href="#section-5.6-other-functions-on-higher-rank-arrays" class="section-link">§</a></h3>

Other functions that you’ve seen applied to vectors also apply to higher-rank arrays:

<ul>

<li>first</li>

<li>scalar functions</li>

</ul>

<h4 id="first">First<a href="#first" class="section-link">§</a></h4>

The first (<code>↑</code>) function ignores the structure of its argument and selects the leading item. For any array:

Therefore, if you know how first works on a vector, you know how it works on any array. Here is an example:

<pre> G←2 2⍴(4 6⍴⍳24) 'TWO' (3 3⍴0) (3 4)

↑G

1 2 3 4 5 6

7 8 9 10 11 12

13 14 15 16 17 18

19 20 21 22 23 24

⍴↑G

4 6

↑↑G

1</pre>

First applied to an empty array returns an array that identifies the kind of data used in constructing the empty array. Here is an example:

<pre> ↑10

NA1←(1 2 3)(4 5 6)(7 8 9)(10 11 12)

↑0⍴NA1

0 0 0</pre>

This result may be a surprise. <code>NA1</code> is a four-item vector of three-item vectors. <code>0⍴NA1</code> is an empty vector. The result of <code>↑0⍴NA1</code> indicates that the empty vector <code>0⍴NA1</code> was constructed from an array whose first item was a three-item numeric vector. If you experiment with various empty arrays, you’ll see that the first item of the non-empty array determines the nature of the result you get from using first on the empty array. This structure of an empty array is called the prototype of the array.

Empty arrays with structure gave rise to the Great Empty Array Joke contest described in <a href="appendixD.html">Appendix D</a>.

In <a href="chapter2.html">Chapter 2</a>, you saw pick applied to vectors. Recall this example from <a href="chapter2.html">Chapter 2</a>:

<pre> PRD←('LPS' 6.95)('TAPES' 7.95)('CDS' 12.95)

1⊃2⊃PRD

TAPES

2 1⊃PRD

TAPES</pre>

Pick with a left argument of length 2 is like writing two picks with one-item left arguments. Notice the reversal of the numbers.

However, a single number is not enough to identify an item in a higher rank array. For example, for a matrix, two integers are necessary: a row position and a column position. Here is how to select the letter <code>'O'</code> out of the matrix <code>G</code>:

<pre> G←2 2⍴(4 6⍴⍳24) 'TWO' (3 3⍴0) (3 4)

(1 2)3⊃G

O</pre>

Do you see how this result is computed? The left argument of pick is a vector. The first item is again a vector of length <code>2</code> and is suitable for selecting from the rank-2 array <code>G</code>. Row 1, column 2, of <code>G</code> contains the three-item vector <code>'TWO'</code>. The second item in the left argument of pick is <code>3</code> and selects the third item of the character vector, giving the scalar <code>'O'</code> as a result.

Suppose you want to select <code>'TWO'</code>. You might be tempted to write this:

But this is equivalent to this:

Using pick in this way won’t work because the <code>1</code> in the left argument is not enough to select from a matrix. You need a left argument that has one item containing two integers. Enclose produces just that:

<pre> (⊂1 2)⊃G

TWO</pre>

Why do you need enclose in this case when you didn’t need it to select <code>'O'</code>? The answer is that to select from a matrix using pick, you always need a nested left argument.

In conjunction with the each operator, pick can be used to select a set of arrays from arbitrary positions in an array. Here’s how it works:

<pre>If I⊃A gives X

J⊃A gives Y

and K⊃A gives Z

Then I J K⊃¨A A A gives X Y Z</pre>

The right argument shown is a three-item vector whose each item is <code>A</code>. A scalar on the right of any derived function of each is extended. So, using enclose to create the scalar, the example looks like this:

<h4 id="scalar-functions">Scalar Functions<a href="#scalar-functions" class="section-link">§</a></h4>

The scalar functions extend to arrays of rank 2 or greater in the way you would expect. A monadic scalar function is applied to each item of its argument:

<pre> −2 3⍴⍳6

¯1 ¯2 ¯3

¯4 ¯5 ¯6</pre>

A dyadic scalar function is applied between corresponding items of its two arguments, which conform if they have the same shape:

<pre> (2 3⍴⍳6) + 10 × 2 3⍴⍳6

11 22 33

44 55 66</pre>

With all arrays, the dyadic scalar functions are extended to permit one argument to be a scalar even though the other argument is not a scalar. The array inside the scalar pairs with each item from the non-scalar array:

<pre> 1+10×2 3⍴⍳6

11 21 31

41 51 61

(⊂1 2 3) + 10× 2 3⍴⍳6

11 12 13 21 22 23 31 32 33

41 42 43 51 52 53 61 62 63</pre>

In this last example, the right argument has shape <code>2 3</code>, so the result has shape <code>2 3</code>:

<pre> ⍴(⊂1 2 3) + 10× 2 3⍴⍳6

2 3</pre>

The array inside the scalar is the three-item vector <code>1 2 3</code>. This vector pairs with each of the items from the other argument. Thus, each item of the result is a three-item vector:

<pre> ⍴¨(⊂1 2 3) + 10× 2 3⍴⍳6

3 3 3

3 3 3</pre>

<h4 id="exercises-for-section-5.6">Exercises for Section 5.6[<a href="answers.html#section-5.6-other-functions-on-higher-rank-arrays">Answers</a>]<a href="#exercises-for-section-5.6" class="section-link">§</a></h4>

<ol>

<li>Write three different APL2 expressions to produce a simple scalar from a one-item simple vector <code>N</code>.</li>

<li>Write an APL2 expression to produce the number of rows in matrix <code>M</code> as a scalar.</li>

<li>Given the vector <code>W</code>:

<li>Evaluate the following expressions:

<ol>

</ol></li>

<li>What does <code>↑</code> do in the expression <code>↑,/W</code>?</li>

</ol></li>

<li>Given the array <code>A</code> as follows:

<pre> A←(⍳4)(2 3⍴'ABCDEF')(⊂'XYZ')(6 (7 8))</pre>

Evaluate the following expressions. State the shape and depth of each result:

</ol></li>

<li>Suppose you are given these arrays:

<pre> A← 3 2⍴⍳6

B←10×⍳3

C←'APL2'

D←A B C</pre>

Fill in the blanks in the following expressions so the indicated result is produced:

<li><pre>_______⊃D

APL2 </pre></li>

<li><pre>_______⊃D

P</pre></li>

<li><pre>_______⊃⊂D

P</pre></li>

<li><pre>________⊃D

1 2 3 4 5 6</pre></li>

<li><pre>________⊃D

6</pre></li>

<li><pre>________⊃A

6</pre></li>

<li><pre>______________ A

3 4</pre></li>

</ol></li>

<li>Evaluate the following expressions:

</ol></li>

<li>Evaluate the following expressions:

</ol></li>

</ol>

<h3 id="section-5.7-other-primitive-operators">Section 5.7 — Other Primitive Operators<a href="#section-5.7-other-primitive-operators" class="section-link">§</a></h3>

You’ve already seen the two primitive operators each and reduction. This section introduces these primitive operators:

<ul>

<li>n-wise reduction</li>

<li>outer product</li>

<li>inner product</li>

</ul>

The scan (<code>\</code>) operator is defined in terms of reduction and, like reduction, applies to any dyadic function. It is best understood by analyzing an example:

<pre> +\ 1 3 5 7 11 13

1 4 9 16 27 40</pre>

First, notice that the shape of the result matches the shape of the argument of the derived function. The first item of the result matches the first item of the argument; the second item of the result is the <code>+/</code> of the first two items. And, in general, the <code>N</code>th item of the result is <code>+/N↑</code>argument. The last item of the result is the same value as <code>+/</code> of the data.

Scan can be applied to any dyadic function:

<pre> ,\ (10 20)(30 40)(50 60)

10 20 10 20 30 40 10 20 30 40 50 60

⍴ ,\ (10 20)(30 40)(50 60)

3</pre>

Scan extends to higher-rank arrays much as reduction does: it can be used with an axis; and the symbol <code>⍀</code> implies a scan along the first axis:

<pre> A←4 6⍴⍳24

+\[1] A

1 2 3 4 5 6

8 10 12 14 16 18

21 24 27 30 33 36

40 44 48 52 56 60

,\ 3 2⍴'AB' 'CD' 'EF' 'GH'

AB ABCD

ED EFGH

AB ABCD

,⍀ 3 2⍴'AB' 'CD' 'EF' 'GH'

AB CD

ABEF CDGH

ABEFAB CDGHCD</pre>

<h4 id="n-wise-reduction">N-wise Reduction<a href="#n-wise-reduction" class="section-link">§</a></h4>

N-wise reduction is the dyadic form of the derived function produced by reduction. It is best understood by analyzing an example:

<pre> 3 +/ 1 3 5 7 11 13

9 15 23 31</pre>

First, notice that the length of the result is less than the length of the right argument. In general, the length of the result is one plus the difference between the length of the right argument and the value of the left argument.

The first item of the result in the preceding example is <code>+/</code> of the first three items of the right argument. The <code>N</code>th item of the result is <code>+/3↑(N−1)↓</code>argument.

The derived function is sometimes called a moving-window reduction. In the preceding example, a window three items wide is moved from left to right across the right argument with a reduction performed at each step.

As an example, suppose that a company has sales figures for the last twelve quarters:

<pre> SALES← 1001 2741 3081 3767 3279 4015 7305

SALES← SALES,7200 7496 9247 5100 7650</pre>

As you can see, there was a big jump in sales during the tenth quarter followed by a big drop in sales in the eleventh quarter. The chief executive officer would like to smooth out these numbers so the monthly fluctuations are not so dramatic. N-wise reduction can do the smoothing:

<pre> (1↑SALES),(2+/SALES)÷2

1001 1871 2911 3424 3523 3647 5660 7252.5 7348

8371.5 7173.5 6375</pre>

The expression just shown replaces every item but the first by the average of it and the preceding quarter. Although there are still peaks and valleys in the data, they are not nearly so drastic. Averaging over more than two items at a time smooths the data even more:

<pre> (3↑SALES),(4+/SALES)÷4

1001 2741 3081 2647.5 3217 3535.5 4591.5 5449.75

6504 7812 7260.75 7373.25</pre>

Another interesting n-wise reduction uses catenate as the operand. As this example shows, n-wise reduction with catenate applied to a simple vector returns a vector of the sub-vectors implied by the moving window:

<pre> 3 ,/ 'ABCDEFGHI'

ABC BCD CDE DEF EFG FGH GHI</pre>

Here’s an example where the argument is not a simple vector:

<pre> 2 ,/ 'BILLY' 'BOB' 'TOM' 'CAT'

BILLYBOB BOBTOM TOMCAT</pre>

By applying n-wise reduction to a vector of scalars instead of a vector of vectors, you can get a vector of pairs of names:

<pre> 2 ,/ ⊂¨'BILLY' 'BOB' 'TOM' 'CAT'

BILLY BOB BOB TOM TOM CAT</pre>

N-wise reduction extends to higher-rank arrays just as reduction and scan do and can be used with an axis. The symbol <code>⌿</code> implies an n-wise reduction along the first axis:

<pre> A←4 6⍴⍳24

2 +/ A

3 5 7 9 11

15 17 19 21 23

27 29 31 33 35

39 41 43 45 47

3+/A

6 9 12 15

24 27 30 33

42 45 48 51

60 63 66 69

3 2⍴'AB' 'CD' 'EF' 'GH'

AB CD

EF GH

AB CD

2 ,/3 2⍴'AB' 'CD' 'EF' 'GH'

ABCD

EFGH

ABCD

⍴2 ,/3 2⍴'AB' 'CD' 'EF' 'GH'

3 1

2,⌿3 2⍴'AB' 'CD' 'EF' 'GH'

ABEF CDGH

EFAB GHCD</pre>

<h4 id="outer-product">Outer Product<a href="#outer-product" class="section-link">§</a></h4>

The operator each applies a function between corresponding items of two arrays. You may also want to apply a function between all pairings of items one from the left argument and one from the right argument. The operator outer product (<code>∘.</code>) creates an “all combinations” derived function. The result of combining items from a two-item vector <code>A B</code> in all combinations with items from a three-item vector <code>C D E</code> looks like this:

</center>

Applying multiplication (<code>×</code>) between pairs of items in all combinations gives a matrix that looks like an operation table for multiplication on integers:

<pre> (⍳5) ∘.× (⍳10)

1 2 3 4 5 6 7 8 9 10

2 4 6 8 10 12 14 16 18 20

3 6 9 12 15 18 21 24 27 30

4 8 12 16 20 24 28 32 36 40

5 10 15 20 25 30 35 40 45 50</pre>

Any dyadic function can be used with outer product. Here’s outer product applied to the function take (<code>↑</code>):

<pre> 2 3 ¯4 ∘.↑ (5 6 7) 'ABC'

5 6 AB

5 6 7 ABC

0 5 6 7 ABC

DISPLAY 2 3 ¯4 ∘.↑ (5 6 7) 'ABC'

.→-----------------.

↓ .→--. .→-. |

| |5 6| |AB| |

| '∼--' '--' |

| .→----. .→--. |

| |5 6 7| |ABC| |

| '∼----' '---' |

| .→------. .→---. |

| |0 5 6 7| | ABC| |

| '∼------' '----' |

'∊-----------------'</pre>

Because the left argument is a three-item vector and the right argument is a two-item vector, the result is a three-by-two array. It is nested because take returned a nonscalar array.

The shape of the result of outer product is the shape of the left argument catenated with the shape of the right argument. This is stated more formally as follows:

<h4 id="inner-product">Inner Product<a href="#inner-product" class="section-link">§</a></h4>

The inner product operator (<code>.</code>) applies two functions in a uniform way to arrays. The following example illustrates the way inner product applies addition and multiplication to vectors:

Suppose you have a three-item vector of hours, minutes, and seconds that you want to convert to scalar seconds. You can do this with primitives you already know:

<pre> +/3600 60 1 × 2 15 30

8130</pre>

The left argument is the vector giving the number of seconds in an hour, the number of seconds in a minute, and the number of seconds in a second. The multiplication converts everything to seconds, and the reduction adds them up. You can write this computation as an inner product as follows:

<pre> 3600 60 1 +.× 2 15 30

8130</pre>

Inner product on vectors is defined more formally in terms of reduction as follows:

The enclose following the reduction in the formal definition is not needed if the reduction returns a simple scalar as it did in the first example; but if <code>G</code> returns a higher-rank array, the reduction would not return a scalar. Here’s an example where the enclose is required:

<pre> 3 4,.⍴'ABC'

ABCA BCAB CABC

DISPLAY 3 4,.⍴'ABC'

.--------------------------.

| .→---------------------. |

| | .→---. .→---. .→---. | |

| | '----' '----' '----' | |

| '∊---------------------' |

'∊-------------------------'</pre>

For matrices and higher-rank arrays, inner product is defined in terms of outer product and reduction. The inner product <code>F.G</code> applies <code>G</code> between rows of the left argument and columns of the right argument in all combinations. Then each of those results is reduced by <code>F</code>.

Here are some pictures that describe how inner product works on matrices:

</center>

The arguments are split along the inner axes—the rightmost axis for the left argument and the leftmost axis for the right argument (this is why the operator is called inner product). The resulting vectors are given to <code>G</code> in all combinations, with the result reduced by <code>F</code>:

</center>

The shape of the result is the shapes of the arguments catenated, with the inner axes removed. This picture shows the result, with an expression to compute each item:

</center>

Here is a small example that you should be able to figure out yourself if you are not at a terminal:

<pre> I←3 3⍴ 14 ¯140 168 ¯40 640 ¯84O 27 ¯540 756

14 ¯140 168

¯40 640 ¯840

27 ¯540 756

J←3 3⍴÷⍳9

1 0.5 0.33333333

0.25 0.2 0.16666667

0.14285714 0.125 0.11111111

I+.×J

3 0 0

0 3 0

O 0 3</pre>

Depending on the system you are using, the answer could be slightly different from the values shown here. In particular, zero values might be shown as very small numbers (on an IBM 370, in the range of <code>1E¯16</code>). For most numerical computations, that’s close enough to zero compared to the other numbers in the result.

In mathematics, the <code>+.×</code> inner product is often called matrix product.

The shape of the result of inner product is the shape of the left argument without its rightmost axis joined with the shape of the right argument without its leftmost axis. This can be expressed formally for non-scalar arguments as follows:

<h4 id="exercises-for-section-5.7">Exercises for Section 5.7[<a href="answers.html#section-5.7-other-primitive-operators">Answers</a>]<a href="#exercises-for-section-5.7" class="section-link">§</a></h4>

<ol>

<li>State the shape, depth, and value for each of the following expressions:

</ol></li>

<li>Determine the value, shape, and depth of the following expressions where <code>T</code> is defined as:

</ol></li>

<li>State the shape, depth, and result of each of the following expressions, where

</ol></li>

<li>State the shape, depth, and result of each of the following expressions where:

<pre> M←4 4⍴2 4 6 8 1 3 5 7 8 9

N←10×M

T←3 3 3⍴⍳27

S←−T</pre>

</ol></li>

<li>Given a positive integer <code>N</code>, write an expression to generate the following vector:

<li>Write a function <code>CHECK</code> to produce a Boolean vector with <code>1</code>’s for the rows of numeric matrix <code>M</code> that are in ascending order. Here is an example:

<pre> M

2 3 4 5

3 1 7 8

4 7 9 2

CHECK M

1 0 0</pre></li>

<li>Write an expression to produce <code>R</code>, given the result of <code>+\R</code>. For example, given the vector <code>N</code> where <code>N←+\ 2 4 5 7</code>, produce <code>2 4 5 7</code>.</li>

<li>Write an expression to generate sets of <code>N</code> consecutive integers where the first item is from <code>⍳S</code>. For example, from <code>N←3</code> and <code>S←⍳4</code>, you should get the following result:

<li>Write a function <code>MOVING_AVG</code> to produce the average of each successive group of <code>N</code> items from a simple vector of numeric data.</li>

<li>Write an expression to convert 3 miles, 6 yards, 2 feet, and 7 inches to inches (1 mile is 1760 yards, 1 yard is 3 feet, 1 foot is 12 inches).</li>

<li>Given the following variables:

<pre> A←2 4 6

5←10 11 12 13

C←(5 10) (1 2 4)</pre>

Evaluate these expressions:

</ol></li>

<li>State both the value and shape of the following expressions:

</ol></li>

<li>Write an expression to produce all nine pairings of the letters <code>ABC</code> (including repetitions).</li>

<li>Evaluate the following expressions:

</ol></li>

<li>The risk level for cardiovascular disease involves <code>HDL</code> (high density lipoprotein), <code>LDL</code> (low density lipoprotein), triglycerides, and cholesterol. It is measured as the ratio of <code>LDL</code> over <code>HDL</code>. As the ratio increases, so does the risk and the extent of the treatment:

<ul>

<li>2-3 — Moderate risk.</li>

<li>3-5 — Dietary care indicated.</li>

<li>5 or more — Candidate for drug therapy.</li>

</ul>

A regular blood analysis provides measures of <code>HDL</code>, total cholesterol (<code>TC</code>), and triglycerides (<code>TRIG</code>). The following expressions relate <code>LDL</code> to the measured items:

<pre> LDL ← TC − HDL + TRIG ÷ 6

RISK ← LDL ÷ HDL</pre>

<li>Calculate the risk ratio for the following values:

<ul>

<li><code>HDL</code>, from 25 to 40 in increments of 5.</li>

<li><code>TRIG</code>, from 120 to 300 in increments of 10.</li>

<li><code>TC</code>, from 175 to 225 in increments of 5.</li>

</ul></li>

<li>Write an expression to produce the values of <code>LDL</code> for each possible combination of the given values of <code>HDL</code>, <code>TRIG</code>, and <code>TC</code>.</li>

<li>Write an expression to compute the risk values.</li>

</ol></li>

</ol>

View this page on the web

View page source