💾 Archived View for tranarchy.fish › ~autumn › apl2 › chapter6.gmi captured on 2023-03-20 at 17:51:19. Gemini links have been rewritten to link to archived content

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

Chapter 6: Working with Data

<tr>

[<a href="chapter5.html"><code>←</code></a>]

</td>

[<a href="contents.html"><code>↑</code></a>]

</td>

[<a href="chapter7.html"><code>→</code></a>]

</td>

</tr>

</table>

</header>

Chapter

<div>

</div>

<h2>Working with Data</h2>

You’ve seen ways to build collections of data and ways to select subsets of data. In handling data, you may find it useful to compare array items, select particular items in an array, omit items, and search and sort through arrays for specified information. This chapter helps you understand how to use APL2 functions to perform such operations and how to manipulate name assignments to replace values in variables. For work with numeric data, it presents five more computational functions and expands on the power function introduced in <a href="chapter2.html">Chapter 2</a>.

<h3 id="section-6.1-ways-of-comparing">Section 6.1 — Ways of Comparing<a href="#section-6.1-ways-of-comparing" class="section-link">§</a></h3>

This section shows you how to do various comparisons with relational functions, the matching function, and Boolean functions. In APL2, when a comparison is true, the result is <code>1</code>. When a comparison is not true, the result is <code>0</code>. One and zero are sometimes called truth values. In APL2, truth values are just numbers and can be used in computations just like any other numbers.

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

The relational functions are dyadic scalar functions that compare groups of data. The following table summarizes the APL2 relational functions:

<table>

<caption>Table 6.1 APL2 Relational Functions</caption>

<thead>

<th style="text-align: center;">Symbol</th>

</tr>

</thead>

<tbody>

<tr>

</tr>

<tr>

<td class="l r" style="text-align: left;">less than or equal</td>

</tr>

<tr>

<td class="l r" style="text-align: left;">greater than or equal</td>

</tr>

<tr>

<td class="l r" style="text-align: left;">greater than</td>

</tr>

<tr>

<td class="l r" style="text-align: left;">equal</td>

</tr>

<tr>

<td class="l r b" style="text-align: left;">not equal</td>

</tr>

</tbody>

</table>

Here are some examples of the relational functions:

<pre> 3<2

3 4 5 > 4 10 2

0 0 1

5 > 4 10 2

1 0 1</pre>

Since the results of relational functions are numbers, these functions may be used in arithmetic expressions. Here is an example:

<pre> R1←10 0 20

100÷R1+0=R1

10 100 5</pre>

This expression divides <code>100</code> by a vector and avoids an error where the vector contains a zero.

The relational functions are scalar functions. They all work the same way on nested arrays. The function is applied between simple scalars, giving a nested result:

<pre> 10 20 = (18 10 20) (10 30 20)

0 1 0 0 0 1</pre>

Only equal and not equal can be applied to character data:

<pre> 'ABCD' = 'ABCE'

1110

'ABCD' = 'ABCE'

0001</pre>

Be careful when using equal to compare nested character vectors. You might think that the following expression would give the answer <code>1 0</code>:

However, when <code>'JANE'</code> is compared to <code>'JANE'</code> you get a result of <code>1 1 1 1</code>, and when <code>'JIM'</code> is compared to <code>'JOHN'</code> you get a <code>LENGTH ERROR</code>. Even if you fixed the example to avoid the <code>LENGTH ERROR</code>, you would not get the result <code>1 0</code>. Here is an example:

<pre> 'JANE' 'JIM' = 'JANE' 'JOE'

1 1 1 1 1 0 0 </pre>

The next section shows how to get the comparison you want.

You must exercise care when using the relational functions with numbers resulting from a computation. Machine arithmetic is not always exact. For example, the result of the expression <code>1÷3</code> requires an infinite number of digits to represent it as a decimal fraction. APL2 adjusts the relational functions for small inaccuracies. Here is an example:

<pre> .3333333333333 = .33333333333333

1</pre>

The numbers are not really equal (the first number has 13 digits and the second, 14 digits), but they are close enough. Exactly how close two numbers need to be before APL2 calls them equal depends on the machine architecture and the APL2 implementation.

The relational functions all do a “close enough” comparison and so they are called fuzzy functions and the two numbers in the example just shown are said to be equal within fuzz (also called the comparison tolerance). This book does not discuss the precise definition of fuzz. Comparisons with zero are never fuzzed, so if you want exact comparisons, compare against zero:

<pre> .3333333333333 = .33333333333333

.3333333333333 − .33333333333333

¯3.000377724E¯14

0=.3333333333333 − .33333333333333

0</pre>

The above example shows that although the two given numbers are equal within fuzz, their difference is not zero. The actual number you get for the subtraction depends on the system you are using.

<h4 id="match">Match<a href="#match" class="section-link">§</a></h4>

The function match (<code>≡</code>) is like the relational functions in that it returns a <code>1</code> or a <code>0</code>. It is different because it always returns a single <code>1</code> or a single <code>0</code> depending on whether its arguments have the same value and the same structure.

On simple scalars, match is the same as equal:

<pre> 5 ≡ 5

3 ≡ 4

0</pre>

On other arrays, match returns a <code>1</code> only if the two arguments have the same shape and corresponding items match:

<pre> 'JIM' ≡ 'JOHN'

2 3 (4 5) ≡ 1 + 1 2 (3 4)

1</pre>

You sometimes want to know whether two arrays (say, <code>X</code> and <code>Y</code>) have the same shape. You might be tempted to write:

But if <code>X</code> and <code>Y</code> have different rank, this expression will yield a <code>LENGTH ERROR</code>. Instead, write this:

In the discussion of the relational functions, you saw that the following example gave a <code>LENGTH ERROR</code> when you wanted the result <code>1 0</code>:

<pre> 'JANE' 'JIM' = 'JANE' 'JOHN'

LENGTH ERROR

'JANE' 'JIM' = 'JANE' 'JOHN'

^ ^</pre>

Can you use match to produce the desired result?

<pre> 'JANE' 'JIM' = 'JANE' 'JOHN'

0</pre>

No. Match compares the arguments for value and structure. The argument <code>'JANE' 'JIM'</code> does not match the argument <code>'JANE' 'JOHN'</code> in value and structure. Therefore, match returns a 0. What you really want is to match items in corresponding positions. To do that, you use match-each:

<pre> 'JANE' 'JIM' ≡¨ 'JANE' 'JOHN'

1 0</pre>

Match-each does what your intuition might say equal should do. Equal is a scalar function so it works like all the other scalar functions.

<h4 id="a-boolean-functions">A Boolean Functions<a href="#a-boolean-functions" class="section-link">§</a></h4>

You’ve just seen a set of functions that return, as results, arrays of truth values—<code>0</code>’s and <code>1</code>’s. Such arrays are Boolean arrays (named after George Boole, who invented Boolean algebra). The Boolean functions are a set of functions that, given Boolean arrays, produce Boolean arrays. The following tables summarize the Boolean functions:

<table>

<caption>Table 6.2 Dyadic Boolean Functions</caption>

</colgroup>

<thead>

<th style="text-align: center;">Symbol</th>

<th style="text-align: left;">Produces <code>1</code> if</th>

</tr>

</thead>

<tbody>

<tr>

<td class="l t r" style="text-align: left;">Both arguments are <code>1</code></td>

</tr>

<tr>

<td class="l r" style="text-align: left;">Either argument is <code>1</code></td>

</tr>

<tr>

<td class="l r" style="text-align: left;">Both arguments are <code>0</code></td>

</tr>

<tr>

<td class="l r" style="text-align: left;">Either argument is <code>0</code></td>

</tr>

<tr>

<td class="l r" style="text-align: left;">equal</td>

<td class="l r" style="text-align: left;">Both arguments are the same</td>

</tr>

<tr>

<td class="l r b" style="text-align: left;">exclusive or</td>

<td class="l r b" style="text-align: left;">Either but not both are <code>1</code></td>

</tr>

</tbody>

</table>

Notice that <code>=</code> and <code>≠</code> can be considered either Boolean or relational. If you think comparisons, <code>≠</code> is not equal. If you think truth values, <code>≠</code> is exclusive or.

There is one monadic Boolean function:

<table>

<caption>Table 6.3 Monadic Boolean Functions</caption>

</colgroup>

<thead>

<th style="text-align: center;">Symbol</th>

<th style="text-align: left;">Produces <code>1</code> if</th>

</tr>

</thead>

<tbody>

<tr>

<td class="l t r b" style="text-align: left;">argument is <code>0</code></td>

</tr>

</tbody>

</table>

Here are some examples of the Boolean functions:

<pre> 0 1 0 1 ∧ 0 0 1 1

0 0 0 1

0 1 0 1 ≠ 0 0 1 1

0 1 1 0</pre>

The Boolean functions are easy to implement in electronic circuits, and so they are the functions that describe most of the hardware in a digital computer.

The Boolean functions are useful in making connections between relational expressions. For example, suppose you wanted to know which products cost less than $10 but more than $7:

<pre> RETAIL←6.95 7.95 12.95

RETAIL<10

1 1 0

RETAIL>7

0 1 1</pre>

You can connect these into one expression using and. Here is an expression that gives <code>1</code> for a product that costs more than $7.00 but less than $10:

<pre> (RETAIL<10) ∧ (RETAIL>7)

0 1 0</pre>

In combinations with the reduction operator (<code>/</code>), the Boolean functions can answer some interesting questions.

Do all products cost less than $10?

<pre> ∧/RETAIL<10

0</pre>

Does any product cost less than $10?

<pre> ∨/RETAIL<10

1</pre>

</blockquote>

Given a Boolean vector, an exclusive-or-reduction (<code>≠/</code>) tells you whether there is an odd number of <code>1</code>’s:

<pre> ≠/ 1 0 1 1 0 1 0 0

≠/ 1 0 1 1 0 1 0 0 1

1</pre>

Checking for an odd number of <code>1</code>’s is a parity check. Be sure you can figure out these last two examples. They can help you improve your understanding of reduction.

Not (<code>∼</code>) can be used to select a complementary set. For example, if you want to produce a 1 when two arrays are not identical, apply not to match:

<pre> A←'ONE'

B←'ANOTHER'

∼A≡B

1</pre>

To determine products that don’t cost in the range from 7 to 10 dollars, you could enter:

<pre> ∼(RETAIL<10) ∧ (RETAIL>7)

1 0 1</pre>

This can be expressed more compactly using nand:

<pre> (RETAIL<10) ⍲ (RETAIL>7)

1 0 1</pre>

Some interesting derived functions arise from applying the scan (<code>\</code>) operator to Boolean functions.

And-scan (<code>∧\</code>) keeps leading <code>1</code>’s in a Boolean vector. Any <code>1</code>’s after the first <code>0</code> are set to <code>0</code>:

<pre> ∧\1 1 1 1 0 1 0 1 1

1 1 1 1 0 0 0 0 0</pre>

Or-scan (<code>∨\</code>) does a similar operation for <code>0</code>’s; that is, or-scan keeps the leading <code>0</code>’s but changes other <code>0</code>’s to <code>1</code>’s.

<pre> ∨\0 0 0 0 1 0 1 0 1

0 0 0 0 1 1 1 1 1</pre>

Exclusive-or-scan or not equal-scan (<code>≠\</code>) spreads <code>1</code>’s over <code>0</code>’s until the next <code>1</code>:

<pre> ≠\0 0 0 1 0 0 1 0 0 0 1 0 0

0 0 0 1 1 1 0 0 0 0 1 1 1</pre>

An and-scan (<code>∧\</code>) is used in an expression that deletes leading blanks from a character string. The following example shows the construction of the expression:

<pre> TX←' LEADING BLANKS '

TX=' '

1 1 1 1 1 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1

∧\TX=' '

1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

+/∧\TX=' '

(+/∧\TX=' ')↓TX

LEADING BLANKS </pre>

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

<ol>

<li>Write an expression to count the number of simple scalar 0’s in an array.</li>

<li>Write an expression to compute the magnitude of a vector without using the magnitude function. Test your application with the vector <code>V← ¯21 23 0 ¯1</code></li>

<li>Write the APL2 expression that will produce the results shown in the columns of the following table. Your expressions should contain at most one APL2 relational or Boolean function and either <code>A</code> or <code>B</code> or both <code>A</code> and <code>B</code>. <code>A</code> and <code>B</code> have the following values:

<pre> A← 0 0 1 1

B← 0 1 0 1</pre>

For example, to compute the result in column 2. use the expression <code>A∧B</code>.

<pre>A B │ 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

────┼──────────��────────────────────────────

0 0 │ 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1

0 1 │ 0 0 0 0 1 1 1 1 0 0 0 0 1 1 1 1

1 0 │ 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1

1 1 │ 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1</pre></li>

<li>Using the variable <code>RETAIL</code>, write an expression to calculate how many products cost less than 10 dollars.</li>

<li>Write an expression to return a <code>1</code> if a number <code>N</code> is an integer.</li>

<li>Investigate the result of applying less than-scan (<code><\</code>) to Boolean vectors. How would you describe the function performed?</li>

<li>Write a function called <code>COUNTVOWELS</code> to count the number of vowels in a character string and calculate the ratio of vowels to characters in the string. Display the result as a three-column table. The first column should be the vowels (AEIOUY); the second column should be the number of occurrences of that vowel in the string; and the third column should display the ratio as a percentage truncated to a whole number. Your function should produce a result as follows:

<pre> COUNTVOWEL 'A ROSE IS NOT A DAISY'

NUMBER PERCENT

A 4 17

E 1 4

I 2 8

O 2 8

U 0 0

Y 1 4</pre></li>

<li>Predict the result, shape, and depth of the following expressions. Explain any errors that would occur:

<li><code>'SMITH'='SMITH'</code></li>

<li><code>'SMITH'='SMYTH'</code></li>

<li><code>'SMITH'='SMITHY'</code></li>

<li><code>'SMITH'≡'SMITH'</code></li>

<li><code>'SMITH'≡'SMYTH'</code></li>

<li><code>'SMITH'≡'SMITHY'</code></li>

<li><code>'ROY' 'SMITH' = 'ROB' 'SMITH'</code></li>

<li><code>'ROY' 'SMITH' ≡ 'ROB' 'SMITH'</code></li>

<li><code>'ROY' 'SMITH' ≡¨ 'ROB' 'SMITH'</code></li>

</ol></li>

<li>In logic, the statement “If P is true, then Q is true” is called implication. Another way of phrasing this statement is “If P is false, then Q may be either true or false.”

<li>Write an expression to compute the truth table for implication using the functions <code>∨</code> and <code>∼</code>.</li>

<li>What single APL2 function also yields implication?</li>

</ol></li>

<li>Write an expression that produces an array with the same values as <code>M</code> except that <code>0</code>’s are replaced by <code>1</code>’s.</li>

<li>Write an expression to round up any positive number as follows:

<li>To the next higher multiple of .5.</li>

<li>To the nearest multiple of .5.

For example,

(a) results in <code>2.5 2.5 3 3 3.5 3.5</code>

(b) results in <code>2 2.5 2.5 3 3 3</code></li>

</ol></li>

</ol>

<h3 id="section-6.2-selecting-subsets-of-arrays">Section 6.2 — Selecting Subsets of Arrays<a href="#section-6.2-selecting-subsets-of-arrays" class="section-link">§</a></h3>

Selecting and working with subsets is a fundamental activity when you deal with array data structures. This section discusses these operations for selecting and working with subsets:

<ul>

<li>indexing</li>

<li>replicate</li>

<li>expand</li>

<li>without</li>

<li>selective assignment</li>

</ul>

<h4 id="indexing">Indexing<a href="#indexing" class="section-link">§</a></h4>

As you have learned, APL2 arrays are ordered collections of data. In a vector, there is conceptually a first item, a second item, and so forth. In a matrix, there is conceptually a first row, a first column, a second row, a second column, and so forth. This ordering makes it possible to identify any item in an array by using a set of integers to indicate the position in the array. This set of integers is the index of the item in the array. Mathematicians use the term subscript for the same concept.

<a href="chapter2.html">Chapter 2</a> explained indexing applied to vectors. Here is an example:

<pre> 'TAPES'[3 2 5 1 4]

PASTE

'TAPES'[1 4 2]

TEA</pre>

When you want to index a rank-<code>N</code> array, you must specify an integer for each of the axes. With the indexing function, these <code>N</code> numbers are written inside the square brackets and are separated by semicolons. For example, to select the item in row 2, column 3, of a matrix, you enter

<pre> AC← 3 4⍴'ABCDEFGHIJKL'

ABCD

EFGH

IJKL

AC[2;3]

G</pre>

To select a cross-section of items, you specify a vector of indices in one or more of the index positions. Here’s an expression that selects both column 1 and column 3 from row 2 of matrix <code>AC</code>:

<pre> AC[2;1 3]

EG</pre>

When you specify more than one number in any index position, you are requesting that these numbers be used together with the numbers in the other index positions in all combinations. Therefore, if you index two of the rows and three of the columns in a matrix, you select six items:

<pre> AC[2 3;2 3 4]

FGH

JKL</pre>

Here is a diagram of this selection:

</center>

You can, of course, select an entire row of a matrix by specifying that row and every column in order:

<pre> AC[2;1 2 3 4]

EFGH</pre>

You can indicate the selection of every item along some axis more concisely by putting no value in the index position. Using this notation, you can select every item in row 2:

<pre> AC[2;]

EFGH</pre>

Here’s an example that selects every row of columns 1 and 3:

<pre> AC[;1 3]

IK</pre>

Leaving out an index is equivalent to writing a vector of integers from <code>1</code> up to the length of the axis.

In the preceding two examples, the indices left out are equivalent, respectively, to these expressions:

<pre> ⍳ (⍴AC)[2]

1 2 3 4

⍳ (⍴AC)[1]

1 2 3</pre>

Eliding an axis selects all items along the corresponding axis. Therefore:

<pre> AC[2;] <--> AC[2;⍳(⍴AC)[2]]

AC[;1 3] <--> AC[⍳(⍴AC)[1],1 3]</pre>

So far, the examples of indexing have used only scalars and vectors as indices. Higher rank arrays may also be used as indices. Here are two examples where a matrix is used to index a matrix:

<pre> AC[2;2 2⍴ 1 3 1 2]

AC[2 1;2 2⍴ 1 3 1 2]

AB</pre>

With such generality in the indices, it may seem difficult to predict the kind of array that a given application of indexing produces. In fact, however, computing the result of indexing is easy if you remember the following rules about rank and shape.

<ol>

<li>Rank of indexing: The rank of the result of indexing is the sum of the ranks of the indices. The rank of an elided index is one.

The following examples show this rule applied to some of the previous examples:

<table>

<thead>

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

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

</tr>

</thead>

<tbody>

<tr>

<td class="l t r b" style="text-align: left;"><pre>(⍴⍴2)+(⍴⍴3)

0 + 0</pre></td>

</tr>

<tr>

<td class="l t r b" style="text-align: left;"><pre>(⍴⍴2)+(⍴⍴1 3)

0 + 1</pre></td>

</tr>

<tr>

<td class="l t r b" style="text-align: left;"><pre>(⍴⍴2 1)+(⍴⍴MI)

1 + 2</pre></td>

</tr>

<tr>

<td class="l t r b" style="text-align: left;"><pre>MI←3 4⍴ 1 3 4 2 1

AC[2 1;MI]</pre></td>

<td class="l t r b" style="text-align: left;"><pre>(⍴⍴2 1)+(⍴⍴MI)

1 + 2</pre></td>

</tr>

<tr>

<td class="l t r b" style="text-align: left;"><pre>((⍳⍴⍴AC)[1])+(⍴⍴2 3)

1 + 1</pre></td>

</tr>

</tbody>

</table>

</li>

<li>Shape of indexing: The shape of the result of indexing is the catenate of the shapes of the indices. The shape of an elided index is the length of the axis corresponding to that index.

The following examples show this rule applied to the same expressions as the examples for rule 1:

<table>

<thead>

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

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

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

</tr>

</thead>

<tbody>

<tr>

<td class="l t r b" style="text-align: center;"><code>⍳0</code> (empty)</td>

<td class="l t r b" style="text-align: left;"><pre>(⍴2),(⍴3)

(⍳0),(⍳0)</pre></td>

</tr>

<tr>

<td class="l t r b" style="text-align: left;"><pre>(⍴2),(⍴1 3)

(⍳0),(,2)</pre></td>

</tr>

<tr>

<td class="l t r b" style="text-align: left;"><pre>(⍴2 1),(⍴MI)

(,2) ,(,3)</pre></td>

</tr>

<tr>

<td class="l t r b" style="text-align: left;"><pre>MI←3 4⍴ 1 3 4 2 1

AC[2 1;MI]</pre></td>

<td class="l t r b" style="text-align: left;"><pre>(⍴2 1),(⍴MI)

(,2) ,(3 4)</pre></td>

</tr>

<tr>

<td class="l t r b" style="text-align: left;"><pre>(⍴AC)[1],⍴2 3

3 , (,2)</pre></td>

</tr>

</tbody>

</table>

</li>

<li>Values selected by indexing: Once you know the rank and | shape of the result, you can easily compute the values. The first item of the result is the item indicated by the first item of each index. The remaining items of the result come from using the indices in order. A given index has all its values used for a fixed value from the index to its left.

Here is a diagram in the shape of the result of the operation <code>AC[2 1;MI]</code>. Each position is labeled with the row and column index used to select an item for the result:

</center>

<pre> AC←3 4⍴'ABCDEFGHIJKL'

MI←3 4⍴ 1 3 4 2 1

AC[2 1;MI]

EGHF

EEGH

FEEG

ACDB

AACD

BAAC</pre></li>

</ol>

An attempt to select an item that doesn’t exist gives the message <code>INDEX ERROR</code>:

<pre> 'ABC'[5]

INDEX ERROR

'ABC'[5]

∧ ∧</pre>

You can use indexing to plot simple graphs. For example, suppose the variable <code>SALES</code> represents the number of computer systems that a company sold each month in its first year of operation:

<pre> SALES←1 0 3 5 2 7 10 7 10 5 3 2</pre>

Comparing these monthly sales numbers in all combinations with the integers from 1 to 10, gives an array of <code>1</code>’s and <code>0</code>’s that, if you squint your eyes, looks like a graph:

<pre> (⍳10)∘.≤SALES

1 0 1 1 1 1 1 1 1 1 1 1

0 0 1 1 1 1 1 1 1 1 1 1

0 0 1 1 0 1 1 1 1 1 1 0

0 0 0 1 0 1 1 1 1 1 0 0

0 0 0 0 0 1 1 1 1 0 0 0

0 0 0 0 0 0 1 0 1 0 0 0

0 0 0 0 0 0 1 0 1 0 0 0</pre>

You can use indexing to change the 0’s and 1’s into blanks and symbols so the data is easier to analyze:

<pre> ' ⎕'[1+(⍳10)∘.≤SALES]

⎕ ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

⎕⎕ ⎕⎕⎕⎕⎕⎕

⎕ ⎕⎕⎕⎕⎕

⎕⎕⎕⎕

⎕ ⎕

⎕ ⎕</pre>

A graph like this is a histogram or a bar chart. Most often, in a histogram you want the stacks to build upward not downward. One of many ways to build upward is to do the comparison with the integers from 10 to 1 instead of 1 to 10:

<pre> ' ⎕'[1+(11−⍳10)∘.≤SALES]

⎕ ⎕

⎕⎕⎕⎕

⎕ ⎕⎕⎕⎕⎕

⎕⎕ ⎕⎕⎕⎕⎕⎕

⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕

⎕ ⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕</pre>

Note: IBM’s APL2 Release 3 adds the function indexing (<code>⌷</code>) as an alternative form of indexing. For information on this new function, see <a href="appendixF.html">Appendix F</a>.

<h4 id="selecting-items-with-a-mask-replication">Selecting Items with a Mask: Replication<a href="#selecting-items-with-a-mask-replication" class="section-link">§</a></h4>

Indexing can select zero or more of each item of a vector. If you do not specify the index to an item, indexing doesn’t select the item at all. If you specify the index once, the item is selected once. Specify the index twice and you get the item twice; and so forth:

<pre> CV1←'SANDY'

CV1[2 2 3 5 5 5]

AANYYY</pre>

The APL2 operator replicate—often called compress—gives a different way of doing this kind of selection. The left operand is a vector as long as the right argument and indicates how many times to select the corresponding item from the right argument:

<pre> 0 2 1 0 3/CV1

AANYYY</pre>

A left operand of only <code>1</code>s and <code>0</code>s is very useful in selecting a subset of items. For example, if <code>SALARY</code> is a vector of salaries, you can select all salaries greater than 5000 with the following expression:

<pre> SALARY←6500 4200 3700 9200 6700

(SALARY>5000)/SALARY

6500 9200 6700</pre>

<code>SALARY>5000</code> evaluates to true (<code>1</code>) or false (<code>0</code>) for each item of salary:

<pre> SALARY>5000

1 0 0 1 1</pre>

Thus, the expression is equivalent to

<pre> 1 0 0 1 1/SALARY

6500 9200 6700</pre>

A vector of <code>1</code>’s and <code>0</code>’s used as the left operand of replicate is often called a mask. Here’s an example of a mask generated by Boolean functions that is then applied to a nested array:

<pre> RETAIL←6.95 7.95 12.95

WHAT←'LPS' 'TAPES' 'CDS'

(RETAIL<10) ∧ (RETAIL>7)

0 1 0

((RETAIL<10) ∧ (RETAIL>7))/WHAT

TAPE</pre>

You can use replicate to double the quotation marks in a character vector. Remember that to get one quotation mark on input of a character string, you must enter two quotation marks:

<pre> CV2←'DON''T'

CV2

DON'T

⍴CV2

CV2='''' <---right argument is a scalar quotation mark

0 0 0 1 0

1+CV2=''''

1 1 1 2 1

(1+CV2='''')/CV2

DON''T

⍴(1+CV2='''')/CV2

6</pre>

Replicate also applies to higher-rank arrays by the use of an axis specification. The right argument is split along the specified axis, the vector definition of replicate is applied, and the pieces are put back together again. When an axis is not written, it defaults to the rightmost axis:

<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

1 0 0 0 3 2/A

1 5 5 5 6 6

7 11 11 11 12 12

13 17 17 17 18 18

19 23 23 23 24 24</pre>

Notice that column 1 is selected once, column 5 is selected three times, and column 6 is selected twice.

Replicate along the first axis selects selects rows of a matrix:

<pre> NAMES←4 4⍴'JOHNJIM EV MIKE'

1 0 1 0/[1] NAMES

JOHN

EV </pre>

You can use the symbol <code>⌿</code> for replicate, in which case the axis defaults to the leftmost axis:

<pre> 1 0 1 0⌿NAMES

JOHN

EV </pre>

Note: replicate is an operator, not a function. It is the first operator you’ve seen that takes an array as an operand. Replicate is the same operator as reduction. The name varies according to whether the operand is an array or a function:

<table>

<tbody>

<tr>

<td style="text-align: right;">array<code>/</code></td>

<td style="text-align: left;">— replicate</td>

</tr>

<tr>

<td style="text-align: right;">function<code>/</code></td>

<td style="text-align: left;">— reduction</td>

</tr>

</tbody>

</table>

</center>

In simple cases, you can think of replicate as a function. But in expressions with other operators, you must treat replicate as an operator. Here is an example:

<pre> 1 0 1/¨ 'ABC' (1 2 3)

AC 1 3</pre>

If you add redundant parentheses, this expression looks like this:

<pre> (1 0 1/)¨ 'ABC' (1 2 3)

AC 1 3</pre>

The operator <code>/</code> applies to its operand <code>1 0 1</code> to produce a derived function, which might be called the 1 0 1-replicate function. This monadic derived function is then the operand of the each operator, which applies it to each item of the argument:

<pre> (1 0 1/'ABC')(1 0 1/1 2 3)

AC 1 3</pre>

Applying two masks to two vectors requires some special thought. If you want to apply two masks to two vectors, you might be tempted to try this:

<pre> (1 0 1)(110)/¨ 'ABC' (1 2 3)

DOMAIN ERROR

(1 0 1)(1 1 0)/¨ 'ABC' (1 2 3)

^ ^</pre>

The expression looks as though it should work, but the operator <code>/</code> applies to the operand <code>(1 0 1)(1 1 0)</code> first, and replicate is not defined on a nested left argument. If you want to apply two masks to two vectors, you must write a defined function that does only the replication and then apply that function using each. The following is an example:

<pre> ∇Z←L REP R

[1] ⍝ replicate function

[2] Z←L/R

[3] ∇

(1 0 1)(1 1 0) REP¨ 'ABC' (1 2 3)

AC 1 2</pre>

<code>REP</code> works where <code>/¨</code> fails because <code>REP</code> is a function and <code>/</code> is an operator.

<h4 id="selecting-items-with-a-mask-expansion">Selecting Items with a Mask: Expansion<a href="#selecting-items-with-a-mask-expansion" class="section-link">§</a></h4>

The APL2 operator expand (<code>\</code>) takes a Boolean mask as its left operand. The mask specifies a pattern for building the result. There is a one in the mask for each item in the right argument. Ones in the mask identify where items from the right argument are placed in the result. Zeros in the mask identify where the result should be padded with a fill value:

<pre> 1 1 0 1 0 1\1 2 3 4

1 2 0 3 0 4

1 1 0 1 0 1\'ABCD'

AB C D</pre>

When you apply expand to a nested array, the result is padded with items that look like the first item but with numbers replaced by zeros and characters replaced by blanks:

<pre> 1 0 1\(2 'A' 3)(19 'B' 21)

2 A 3 0 0 19 B 21

DISPLAY 1 0 1\(2 'A' 3)(19 'B' 21)

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

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

| |2 A 3| |0 0| |19 B 21| |

| '+----' '+----' '+------' |

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

Here’s a practical example of expand. Given a vector <code>A</code>, insert between each pair of numbers the average of the pair. For example, with the given array <code>A</code> the desired result <code>NEWA</code> is shown here:

<pre> A←10 12 15 17 16 8

NEWA←10 11 12 13.5 15 16 17 16.5 16 12 8</pre>

Solving this problem mainly requires n-wise reduction and expand. You can easily compute the average of adjacent numbers using n-wise reduction:

<pre> AV←(2+/A)×+.5

11 13.5 16 16.5 12</pre>

Expand with the appropriate mask puts the original numbers into their proper positions in the longer result:

<pre> 1 0 1 0 1 0 1 0 1 0 1\A

10 0 12 0 15 0 17 0 16 0 8</pre>

If you don’t know the shape of <code>A</code>, you can compute the mask instead:

<pre> M←(¯1+2×⍴A)⍴1 0

1 0 1 0 1 0 1 0 1 0 1

M\A

10 0 12 0 15 0 17 0 16 0 8</pre>

The not of the mask puts the average values in their proper place:

<pre> (∼M)\AV

0 11 0 13.5 0 16 0 16.5 0 12 0</pre>

The desired result is achieved by adding the two parts together:

<pre> (M\A)+(∼M)\AV

10 11 12 13.5 15 16 17 16.5 16 12 8</pre>

When you apply expand to a higher-rank array, an axis may be specified. If no axis is specified, APL2 assumes the rightmost axis. The right argument is split into an array of vectors along the indicated axis, and the vector definition of expand is applied to each vector. Here is an example:

<pre> CH←3 5⍴'ABCDEFGHIJKLMNO'

ABCDE

FGHIJ

KLMNO

1 1 0 0 1 0 1 1\CH

AB C DE

FG H IJ

KL M NO

1 1 0 1\[1]CH

ABCDE

FGHIJ

KLMNO</pre>

The symbol <code>⍀</code> may be used to signify expansion along the first axis. Note: Like replicate, expand is an operator, not a function.

<h4 id="without">Without<a href="#without" class="section-link">§</a></h4>

It is possible to select items from a vector by specifying the items not wanted. The function without (<code>∼</code>) returns its left argument with any occurrences of items from the right argument deleted:

<pre> 'THIS AND THAT'∼'HT'

IS AND A

'BILLY JOE ' ∼ ' '

BILLYJOE</pre>

The example shows a quick way to remove blanks from a character vector. These blanks could arise because of the use of an enclose, as in this example:

<pre> NAMES←4 4⍴'JOHNJIM EV MIKE'

⊂[2] NAMES

JOHN JIM EV MIKE</pre>

Because these vectors came from a 4-by-4 matrix, each is a vector of length 4 and some have trailing blanks. The following expression deletes the blanks from each item:

<pre> (⊂[2]NAMES)∼¨' '

JOHN JIM EV MIKE</pre>

Finally, without can compute the intersection of two arrays (that is, the items that occur in both arrays) as follows:

Here is an example:

<pre> 1 3 5 7 9 ∼ 1 3 5 7 9 ∼ 3 7 11

3 7</pre>

<h4 id="selective-assignment">Selective Assignment<a href="#selective-assignment" class="section-link">§</a></h4>

APL2 supplies a variety of ways to organize and extract parts of an array for those situations when you don’t want to operate on the entire array. These functions include reshape, ravel, enclose, take, drop, pick, and indexing. They can be used in combination to express a wide variety of selections. Here is an expression that selects one corner of a matrix that is an item in a nested array:

<pre> SA←10 'ABC' (3 3⍴⍳9) 20 (5 6)

DISPLAY SA

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

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

| 10 |ABC| ↓1 2 3| 20 |5 6| |

| '---' |4 5 6| '∼--' |

| |7 8 9| |

| '∼----' |

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

,2 2↑3⊃SA

1 2 4 5</pre>

You can write any expression that results in a selection of all or part of an array in parentheses on the left of an assignment arrow. APL2 replaces the values selected by that expression with values from the array on the right of the arrow:

<pre> (,2 2↑3⊃SA)←'WXYZ'

DISPLAY SA

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

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

| 10 |ABC| ↓W X 3| 20 |5 6| |

| '---' |Y Z 6| '∼--' |

| |7 8 9| |

| '+----' |

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

If the preceding example does not work on your system, your implementation may not support selective assignment.

An assignment with a selection expression on the left is a selective assignment. The variable whose value is altered is the one whose name appears at the right end of the selection expression (if you ignore square brackets used for indexing).

In these expressions, <code>SA</code> is the only variable whose value is altered:

<pre> (2↑SA)←(10 20)(⍳3)

(SA[4])←⊂2.3 3.4

((5⊃SA)[2])←'S'

((⍳0)⊃SA)←0</pre>

As with any assignment, the explicit result of a selective assignment is the array on the right and does not print. It is, however, available for further computation:

<pre> 1+(2↑SA)←(10 20)(⍳3)

11 21 2 3 4 </pre>

There are three guidelines to help you evaluate an indexed assignment. These guidelines work if the selection expression does not contain any functions that add depth (like enclose), and does not contain operators (like each). You should apply the first guideline that fits the expression you are analyzing. Consult the documentation that comes with your system for a more complete description.

<ol>

<li>If the leftmost function in the selection expression is first or pick, the item selected is replaced by the array on the right of the assignment arrow:

<pre> W←'LPS' 'TAPES' 'DISKS'

(3 4⊃W)←'C'

LPS TAPES DISCS

SA←10 'ABC' (3 3⍴⍳9) 20 (5 6)

(↑2↓SA)←¯1 ¯2

DISPLAY SA

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

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

| 10 |ABC| |¯1 ¯2| 20 |5 6| |

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

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

SA←10 'ABC' (3 3⍴⍳9) 20 (5 6)

(3 (2 2)⊃SA)←'MID'

DISPLAY SA

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

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

| 10 |ABC| ↓ 1 2 3 | 20 |5 6| |

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

| | .→--. | |

| | 4 |MID| 6 | |

| | '---' | |

| | | |

| | 7 8 9 | |

| | | |

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

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

((⍳0)⊃SA)←0

0</pre>

This last selective assignment of <code>SA</code> is like an ordinary assignment (<code>SA←0</code>) except the variable <code>SA</code> must already have a value (even though that value is ignored).</li>

<li>If the array on the right of the assignment is a scalar, it replaces each item selected by the selection expression:

<pre> SA←10 'ABC' (3 3⍴⍳9) 20 (5 6)

SA[1 4 5]←0

DISPLAY SA

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

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

| 0 |ABC| ↓1 2 3| 0 0 |

| '---' |4 5 6| |

| |7 8 9| |

| '∼----' |

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

(2 2↑3⊃SA)←0

DISPLAY SA

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

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

| 0 |ABC| ↓0 0 3| 0 0 |

| '---' |0 0 6| |

| |7 8 9| |

| '∼----' |

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

Neither the rank nor the shape of the selected array changes.</li>

<li>Each value from the array selected is replaced by the corresponding value from the array on the right of the assignment arrow:

<pre> SA←10 'ABC' (3 3⍴⍳9) 20 (5 6)

SA[1 5]←'ONE' 'FIVE'

DISPLAY SA

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

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

| |ONE| |ABC| ↓1 2 3| 20 |FIVE| |

| '---' '---' |4 5 6| '----' |

| |7 8 9| |

| '∼----' |

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

(,2⊃SA)←⍳3

DISPLAY SA

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

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

| |ONE| |1 2 3| ↓1 2 3| 20 |FIVE| |

| '∼--' '∼----' |4 5 6| '∼---' |

| |7 8 9| |

| '∼----' |

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

Neither the rank nor the shape of the selected array changes:

<ul>

<li>The array selected and the array on the right must have the same rank or APL2 produces a <code>RANK ERROR</code>.</li>

<li>The array selected and the array on the right must have the same shape or APL2 produces a <code>LENGTH ERROR</code>.</li>

</ul></li>

</ol>

Note on scalar extension and conformability: APL2 relaxes the conformability rules for selective assignment by ignoring <code>1</code>’s in shape vectors. If you select a subset whose shape is <code>1 5</code>, you may replace the subset by replacement values of shape <code>5 1</code>. Ignoring <code>1</code>’s, each array has shape <code>5</code>. In particular, if the array on the right contains only one item, it is treated as a scalar and extended no matter how many <code>1</code>’s are in its shape.

While any expression that does a selection from an array is permitted on the left of an assignment arrow, implementations may not support them all. Consult the documentation that comes with your system or experiment to see which selections are supported.

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

<ol>

<li>Given the matrix:

Evaluate the following expressions in order and show the value of <code>SA</code> after each is complete. If any expression results in an error, say what causes the error:

</ol></li>

<li>Given the vector:

What is the difference between <code>TM[1]</code> and <code>↑TM</code>?</li>

<li>Write an expression to replace all <code>0</code>’s in a numeric matrix with the character vector <code>N/A</code>. Here is an example:

<pre> 1 0 becomes 1 N/A

0 5 N/A 5</pre></li>

<li>A manufacturing company has just issued a list of serial numbers of their product for recall. These numbers are in the vector <code>RLIST</code>. Write an expression to list which of the company’s products in your inventory vector <code>INVENTORY</code> are on the recall list.</li>

<li>Given simple numeric vector <code>V</code>, write an expression to replace all the numbers in <code>V</code> that are greater than 10 with the character <code>X</code>, leaving the other items alone.</li>

<li>Given two simple arrays <code>M</code> and <code>N</code> with the same rank and shape, write an expression to replace by a blank all items of <code>N</code> different from the corresponding items in <code>M</code>.</li>

<li>Explain why the following expression does not expand each item of <code>B</code> using the corresponding mask from <code>M</code>:

<pre> M←(1 1 0 1)(0 1 0 1)

B←'ABC' 'DE'

M\¨B</pre></li>

<li>Evaluate the following expressions. For each, determine its value and its depth:

<li><code>'BYEBYE' ∼ 'BY'</code></li>

<li><code>'BY' ∼ 'BYEBYE'</code></li>

<li><code>'BYEBYE' ∼ 'BYEBYE' ∼ 'BY'</code></li>

<li><code>'BYEBYE' ∼ ⊂'BY'</code></li>

<li><code>(⊂'BYEBYE') ∼ 'BY'</code></li>

</ol></li>

<li>Evaluate each of the following expressions. For each, state both the result and the depth:

</ol></li>

<li>State the value of each of the following expressions:

<li><code>((2×⍴V)⍴1 0) \ V←'ABCDEF'</code></li>

</ol></li>

<li>Let <code>M1</code>, <code>M2</code>, <code>M3</code> be three rank-2 arrays having the same shape.</li>

</ol>

<li>For a given mask <code>V</code> where <code>(⍴V)≡ ¯1↑⍴M</code>, write an expression that uses <code>V</code> to select the same columns from each of the matrices.</li>

<li>Given three masks <code>V1</code>, <code>V2</code>, <code>V3</code> and matrices <code>M1</code>, <code>M2</code>, and <code>M3</code>, determine how to use each mask to compress the corresponding matrix. (You will need to create a simple defined function first and then use it in an expression.)</li>

<li>Given three masks <code>V1</code>, <code>V2</code>, <code>V3</code>, apply them each to the matrix <code>M</code>, giving three sets of answers. (Note: Use the function defined in part b.)</li>

</ol>

<li>If <code>M</code> is a rank-2 array, the following expression replaces all the items of <code>M</code> by <code>12</code>:

Write an expression to replace all the items in an array of unknown rank by <code>12</code>.</li>

<li>Write an expression to replace all simple scalars in a nested array by <code>21</code>.</li>

</ol>

<h3 id="section-6.3-searching-and-sorting">Section 6.3 — Searching and Sorting<a href="#section-6.3-searching-and-sorting" class="section-link">§</a></h3>

To aid in searching for particular items in an array and sorting items, APL2 provides these functions:

<ul>

<li>index of</li>

<li>membership</li>

<li>grade up and grade down</li>

<li>reverse</li>

<li>rotate</li>

<li>transpose</li>

</ul>

<h4 id="index-of">Index Of<a href="#index-of" class="section-link">§</a></h4>

Index of (<code>⍳</code>) is a function that searches a vector left argument for occurrences of items from the right argument. You can search for many items at one time, but you can search only in a vector. The following is an example:

<pre> LI← 20 40 60 80 40

LI⍳80 40

4 2</pre>

The result always has the same shape as the right argument. Each position in the result is the index position of the first place in the left argument where the item from the right argument is found. Thus, <code>80</code> is found at position 4 in <code>LI</code> and <code>40</code> is found in position 2. The fact that <code>40</code> is also found at position 5 is not reported.

If an item searched for is not found, a number one greater than the length of the left argument is returned:

<pre> LI⍳100

6</pre>

A program can check if a given value is found in another vector by comparing for the number one greater than the length of the vector:

<pre> (⍴LI)<LI⍳100

1</pre>

This expression is true (<code>1</code>) only when the result of index of is the “not found” value. See the program <code>LOOKUP</code> in the section “More About Conditional Branching” in <a href="chapter7.html">Chapter 7</a> for an example of a program that uses this test.

If the left argument is a nested vector, an item from the right is found if it matches an item on the left:

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

WHAT ⍳ 'CDS' 'GUITARS'

3 4</pre>

Here <code>'CDS'</code> is found at position 3, but <code>'GUITARS'</code> is not found at all. Suppose you just want to search for the index of <code>'CDS'</code>. You might think that the following expression would find it:

<pre> WHAT⍳'CDS'

4 4 4</pre>

This is clearly not the answer wanted. Can you figure out why you got the answer <code>4 4</code>? The right argument is a three-item vector containing the characters <code>'C'</code>, <code>'D'</code>, and <code>S</code>, so you get three answers. Remember that vector notation only works for vectors of length two or longer and here you want a right argument with only one item—the vector <code>'CDS'</code>. If you want to search for one item, you must use the function enclose (<code>⊂</code>) to make the vector <code>'CDS'</code> into a one-item array:

<pre> WHAT⍳⊂'CDS'

3</pre>

Now index of finds the three-item vector <code>'CDS'</code> at position 3.

You can use index of on character arguments as a way to convert characters to numbers:

<pre> ALPH←'ABCDEFGHIJKLMNOPQRSTUVWXYZ '

ALPH⍳'SECRET MESSAGE'

19 5 3 18 5 20 27 13 5 19 19 1 7 5</pre>

These numbers are like a code hiding your message. Of course, your code is easy to break by using indexing:

<pre> MESSAGE←ALPH⍳'SECRET MESSAGE'

ALPH[MESSAGE]

SECRET MESSAGE</pre>

This example shows that, in some respects, indexing is the inverse of index of.

You can use index of to select the unique items from a vector. Suppose you have the following vector:

<pre> NV←'JIM' 'JOHN' 'JIM' 'DIETER' 'PIER' 'JIM'</pre>

Index of will find only the first occurrence of each name:

<pre> NV⍳NV

1 2 1 4 5 1</pre>

Comparing this with the first six integers gives a mask for selecting each name only once:

<pre> (NV⍳NV)=⍳⍴NV

1 1 0 1 1 0

((NV⍳NV)=⍳⍴NV)/NV

JIM JOHN DIETER PIER</pre>

<h4 id="membership">Membership<a href="#membership" class="section-link">§</a></h4>

Index of tells you the index of some given item in a vector. If you want to know only whether an item occurs (as opposed to where it occurs), you can use the function membership (<code>∊</code>). Membership gives a <code>1</code> or <code>0</code>, depending on whether each item of the left argument is (<code>1</code>) or is not (<code>0</code>) found in the right argument:

<pre> LI←20 40 60 80 40

100 40∊LI

0 1</pre>

Notice that the array in .which the search takes place is the right argument (just the opposite of index of) and can be any array, not just a vector. In this way, membership is similar to (but not the same as) the membership function found in set theory. In the example, <code>100</code> is not found (giving <code>0</code>) but <code>40</code> is found (giving <code>1</code>).

The following examples illustrate a situation where you might want to know if an item exists but not care about its position:

<pre> (⊂'CDS')∊WHAT

(⊂'GUITARS')∊WHAT

0</pre>

Here, membership is being used to determine whether the character string in the left argument represents a product stocked by the store. If the answer is yes, then you may proceed to look up other information about the product. If the answer is no, there is no point in looking further.

An inner product using addition and membership produces a count of the occurrences from the left argument that can be found in the right argument:

<pre> I←3 10⍴'1988/05/0413:00:00:1A,B,C,D,E '

1988/05/04

13:00:00:1

A,B,C,D,E

⍴I

3 10

⍴'.,:;/\'

I +.∊'.,:;/\'

2 3 4

⍴I +.∊'.,:;/\'

3</pre>

Find (<code>⍷</code>) is like membership except that find looks for the whole left argument and you get, for the result, an indication of everywhere that the left argument occurs. Although find works for any kind of data, it is most useful (and easiest to demonstrate) on character strings:

<pre> 'ABC'⍷'ABABCDABCEAB'

0 0 1 0 0 0 1 0 0 0 0 0</pre>

This result is the same length as the right argument and has a <code>1</code> where the left character string begins. The number of occurrences of the left in the right is:

<pre> +/'ABC'⍷'ABABCDABCEAB'

2</pre>

Here’s a character vector with some redundant blanks:

<pre> PHRASE←'NOW IS THE TIME'</pre>

You can use find to delete the duplicate blanks from <code>PHRASE</code> by looking for two blanks:

<pre> ' '⍷PHRASE

0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0</pre>

This result has a <code>1</code> for each blank to be discarded. Interchanging the <code>1</code>’s and <code>0</code>’s (with not) gives the correct mask for replicate.

<pre> (~' '⍷PHRASE)/PHRASE

NOW IS THE TIME</pre>

<h4 id="grade-up-and-grade-down">Grade Up and Grade Down<a href="#grade-up-and-grade-down" class="section-link">§</a></h4>

In <a href="chapter5.html">Chapter 5</a>, you saw catenate with axis used to build a matrix of possible purchases:

<pre> PURCHASES

LPS .9 6.95

TAPES .9 7.95

CDS 1 12.95

VIDEODISCS 1 19</pre>

It happens that the retail cost is ordered from least to most expensive. This is an accidental ordering but could be useful. Suppose that you add a fifth row to the matrix:

<pre> PURCHASES←PURCHASES,[1]'VIDEOTAPES' 1 13.50

PURCHASES

LPS .9 6.95

TAPES .9 7.95

CDS 1 12.95

VIDEODISCS 1 19

VIDEOTAPES 1 13.5</pre>

Now the price column is no longer in order. APL2 has two functions that order data: grade up (<code>⍋</code>), to arrange data in increasing order, and grade down (<code>⍒</code>), to arrange data in decreasing order. These functions work on vectors of numbers. Here are the functions applied to the price column:

<pre> PURCHASES[;3]

6.95 7.95 12.95 19 13.5

⍋PURCHASES[;3]

1 2 3 5 4

⍒PURCHASES[;3]

4 5 3 2 1</pre>

As you can see, these functions do not produce their argument in sorted order. You might have expected to see grade up return an answer of <code>6.95 7.95 12.95 13.5 19</code>. Instead, you get a vector of small integers. In each example, the answer is a rearrangement of the integers from <code>1</code> to <code>5</code>. These integers are indices that reflect the requested ordering. For example, in grade up, the answer is <code>1 2 3 5 4</code>. These indices mean that to get an increasing vector, you select the first and second items, then the third item, and then the fifth and fourth items, giving the vector sorted in ascending order: <code>6.95 7.95 12.95. 13.5 19</code>. Indexing accomplishes this selection:

<pre> T←PURCHASES[;3]

T[⍋T]

6.95 7.95 12.95 13.5 19

T[⍒T]

19 13.5 12.95 7.95 6.95</pre>

Why is this extra step required? Why shouldn’t the functions just give you the ordered data directly? The answer is that, in practice, you want to rearrange a whole collection of data based on the ordering of one part of the data. The prices sorted in order are not very useful if you can’t identify what product they are associated with. Thus, you want to rearrange the whole matrix based on the order of the prices:

<pre> PURCHASES[⍋PURCHASES[;3];]

LPS .9 6.95

TAPES .9 7.95

CDS 1 12.95

VIDEOTAPES 1 13.5

VIDEODISCS 1 19</pre>

This example shows the rows of <code>PURCHASES</code> rearranged based on the order in the third column.

The grade functions in their dyadic form apply to matrices of character data. The following selects the product names and constructs a matrix from them:

<pre> PNAMES←⊃PURCHASES[;1]

PNAMES

LPS

TAPES

CDS

VIDEODISCS

VIDEOTAPES</pre>

Before the rows of this matrix can be put in order, you have to decide what you mean by the order of characters. To English-speaking people, the order A to Z looks like a good choice. But there are lots of alphabets in the world that use characters not in this set. Even in the roman alphabet, you have to decide where lowercase letters belong. Is a lowercase “a” greater or less than an uppercase “Z”? Whatever you decide, you should code your decision as the left argument of the grade functions. The next three examples show left arguments:

<pre> CS1←' ABCDEFGHIJKLMNOPQRSTUVWXYZ'</pre>

This sample argument, where all roman letters are written, puts capitalized words first and in order.

<pre> CS2←' AaBbCcDdEe ... YyZz'</pre>

<code>CS2</code> puts words starting with <code>A</code> first, followed by words starting with <code>a</code>.

<pre> CS3←2 27⍴' ABCDE ... XYZ abcde ... xyz'</pre>

<code>CS3</code> as a left argument orders the rows of a character matrix and ignores capitalization. In a matrix left argument to the grade functions, characters in the same column are treated as though they are the same character. Because the product names are all in uppercase letters, any of the three preceding arrays as left argument gives the same result:

<pre> CS3⍋PNAMES

3 1 2 4 5</pre>

Again, this result is an index vector that rearranges the data.

<pre> PNAMES[CS3⍋PNAMES;]

CDS

LPS

TAPES

VIDEODISCS

VIDEOTAPES

PURCHASES[CS3⍋PNAMES;] <---This vector rearranges

CDS 1 12.95 the whole table

LPS .9 6.95

TAPES .9 7.95

VIDEODISCS 1 19

VIDEOTAPES 1 13.5</pre>

Double grade up has some surprising uses. For example, suppose you have these three collections of data:

<pre> A←'XYZ'

B← 123

C← 2.1 2.2 2.3</pre>

You want to merge these data collections into the following vector:

Here’s a picture of the mapping. The numbers written under the desired answer indicate which variable the corresponding item came from: 1 for <code>A</code>, 2 for <code>B</code>, and 3 for <code>C</code>:

</center>

Applying a double grade up to the vector of integers in the illustration generates indices that will merge the three vectors in the desired manner:

<pre> MV←1 2 1 3 1 3 2 3 2

⍋⍋MV

1 4 2 7 3 8 5 9 6

(A,B,C)[⍋⍋MV]

X 1 Y 2.1 Z 2.2 2 2.3 3</pre>

<h4 id="reverse">Reverse<a href="#reverse" class="section-link">§</a></h4>

Suppose you have a vector and would like to turn it around so the first item is last and the last item is first. Given a four-item vector, you could index with <code>4 3 2 1</code>:

<pre> V←'POTS'

V[4 3 2 1]

STOP</pre>

If you don’t know the length of the vector to be reversed in advance, you could compute the indices in many ways:

<pre> V[1+(⍴V)−⍳⍴V]

STOP

V[⍒⍳⍴V]

STOP</pre>

The function reverse (<code>⌽</code>) turns the items around in one step:

<pre> ⌽V

STOP</pre>

On higher-rank arguments, reverse with axis applies. For the rightmost axis, you may elide the axis specification:

<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

⌽[1]A

19 20 21 22 23 24

13 14 15 16 17 18

7 8 9 10 11 12

1 2 3 4 5 6

⌽A

6 5 4 3 2 1

12 11 10 9 8 7

18 17 16 15 14 13

24 23 22 21 20 19</pre>

<code>⊖</code> is an alternate symbol for reverse along the first axis:

<pre> ⊖A

18 20 21 22 23 24

13 14 15 16 17 18

7 8 9 10 11 12

1 2 3 4 5 6</pre>

<h4 id="rotate">Rotate<a href="#rotate" class="section-link">§</a></h4>

The function rotate (<code>⌽</code>) shifts the items of a vector by removing items from one side of the vector and reattaching them to the other end. Here is an example:

<pre> PHRASE←'NOW IS THE TIME'

2⌽PHRASE

W IS THE TIMENO</pre>

The left argument gives the number of items for the shift. The name of the function is rotate because the items moved out of the left end reappear on the right end.

A negative left argument causes a shift to the right:

<pre> ¯2⌽PHRASE

MENOW IS THE TI</pre>

The character vector <code>PHRASE</code> used in these examples has some extra blanks in it. Earlier, you saw an expression using find that deletes duplicate blanks. Here’s another way to do the same thing, using rotate:

<pre> P←' '≠PHRASE

1 1 1 0 1 1 0 0 1 1 1 0 0 0 1 1 1 1

P ∨ 1⌽P

1 1 1 1 1 1 0 1 1 1 1 0 0 1 1 1 1 1

(P∨1⌽P)/PHRASE

NOW IS THE TIME</pre>

This selects the non-blank characters and blanks immediately to the left of a non-blank character.

On higher-rank arguments, rotate with axis applies. For the rightmost axis you may elide the axis specification. The right argument is split into vectors along the specified axis. If the left argument is a scalar, each vector is rotated that much:

<pre> 1⌽A

2 3 4 5 6 1

8 9 10 11 12 7

14 15 16 17 18 13

20 21 22 23 24 19

1⌽[1]A

7 8 9 10 11 12

13 14 15 16 17 18

19 20 21 22 23 24

1 2 3 4 5 6</pre>

The symbol <code>⊖</code> is rotate along the first axis:

<pre> 1⊖A

7 8 9 10 11 12

13 14 15 16 17 18

19 20 21 22 23 24

1 2 3 4 5 6</pre>

You may specify a different rotation amount for each of the vectors in an array. If the left argument is a matrix of rank one less than the right argument, then each vector is rotated by the number corresponding to the vector in the split right argument:

<pre> ¯1 0 1 2⌽A

6 1 2 3 4 5

7 8 9 10 11 12

14 15 16 17 18 13

21 22 23 24 19 20</pre>

<h4 id="transpose">Transpose<a href="#transpose" class="section-link">§</a></h4>

The monadic transpose function rearranges an array so that its shape is reversed. In a matrix, transpose turns rows into columns and columns into rows.

<pre> AC←3 4⍴'ABCDEFGHIJKL'

ABCD

EFGH

IJKL

⍉AC

AEI

BFJ

CGK

DHL

⍴⍉AC

4 3</pre>

The following identity describes the shape of the result of transpose:

The dyadic transpose function rearranges its argument and selects a subset of it. The left argument is a list of integers which indicate where in the result the corresponding axis of the right argument should be placed. Here is an example:

<pre> T←2 4 3⍴⍳30

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 2⍉T

1 4 7 10

2 5 8 11

3 6 9 12

13 16 19 22

14 17 20 23

15 18 21 24

⍴1 3 2⍉T

2 3 4</pre>

The following picture shows how to predict the shape of dyadic transpose—use the left argument to map the argument shape to the result shape:

</center>

When a number is repeated in the left argument, more than one axis from the argument is mapped to the same axis in the result, with the result length being the minimum of the mapped shapes. Here’s an example with a matrix argument:

<pre> AC←3 4⍴'ABCDEFGHIJKL'

ABCD

EFGH

IJKL

1 1⍉AC

AFK</pre>

Here is a picture of how the result shape is computed:

</center>

The values selected by this transpose are those where the row index matches the column index: row 1, column 1; row 2, column 2; and row 3, column 3. Now you see why the result shape is the minimum of the axes’ lengths. It is not possible to select row 4, column 4 because there are only three rows.

More general transposes on higher-rank arrays are computed the same way.

The symbol for transpose looks a lot like the two symbols used for reverse: a circle and a straight line. If you apply any of these three functions to a 3-by-3 matrix, the line tells you which items do not move:

<pre> X←3 3⍴⍳9

1 2 3

4 5 6

7 8 9

(⌽X)(⊖X)(⍉X)

3 2 1 7 8 9 1 4 7

6 5 4 4 5 6 2 5 8

9 8 7 1 2 3 3 6 9

(⊂X)=(⌽X)(⊖X)(⍉X)

0 1 0 0 0 0 1 0 0

0 1 0 1 1 1 0 1 0

0 1 0 0 0 0 0 0 1</pre>

<h4 id="exercises-for-section-6.3">Exercises for Section 6.3[<a href="answers.html#section-6.3-searching-and-sorting">Answers</a>]<a href="#exercises-for-section-6.3" class="section-link">§</a></h4>

<ol>

<li>Write an expression that produces an array having the same shape and depth as array <code>A</code> but filled with 0’s except where <code>A</code> has single digit numbers (that is, between <code>¯9</code> and <code>9</code>) for <code>A</code> as follows:

<li>Simple numeric.</li>

<li>Simple but with a mixture of numbers and characters.</li>

</ol></li>

<li>Write an expression that selects all non-zero numbers from a nested numeric array.</li>

<li>Select every item from the array <code>H</code> which is not the character string <code>N/A</code>.</li>

<li>Given simple array <code>A</code> which contains numbers and the character string <code>N/A</code>, write an expression to replace all the numbers by the number <code>100</code>.</li>

<li>Given simple array <code>A</code> which contains numbers and the character string <code>N/A</code>, write an expression to replace each number by <code>100</code> times that number.</li>

<li>Today many cash registers not only print out the cost of each item but also the name of the item. To do this, the system has a <code>STOCK</code> database. Suppose each entry in this database is a vector of three-item vectors. Each three-item vector looks like this: > (inventory number) (product name) (product cost)

For example, here is a specification of the first three items in <code>STOCK</code>:

<pre> CEREAL ←(112 'ALPHABYTE' 1.89)

BREAD←(213 'SO_SOFT BREAD' 1.09)

SOAP←(456 'LIFE GIRL SOAP' 1.75)

STOCK← CEREAL BREAD SOAP</pre>

Define a function that will accept a vector of inventory numbers and the name of the stock database, and will produce a matrix listing of the item names and prices that match the inventory numbers.</li>

<li>You saw the use of index of to delete duplicate items from a vector. Write an expression to delete duplicate rows from a matrix.</li>

<li>Given the following matrix:

<pre> M←(⍳4)∘.≥⍳4

1 0 0 0

1 1 0 0

1 1 1 0

1 1 1 1</pre>

Use reverse and transpose to produce the following arrays:

<li><pre>1 1 1 1

0 1 1 1

0 0 1 1

0 0 0 1</pre></li>

<li><pre>0 0 0 1

0 0 1 1

0 1 1 1

1 1 1 1</pre></li>

<li><pre>1 1 1 1

1 1 1 0

1 1 0 0

1 0 0 0</pre></li>

</ol></li>

<li>Given the following variables:

<pre> B← 'ABC' 'DEFG' 'IJKLM'

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

Evaluate these expressions:

</ol></li>

<li>Given the following array:

Complete the following expressions to produce the stated results:

<li><pre> _________ A

4 3 2 1

8 7 6 5

12 11 10 9</pre></li>

<li><pre> _________ A

9 10 11 12

5 6 7 8

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

<li><pre> _________ A

12 11 10 9

8 7 6 5

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

<li><pre> _________ A

2 3 4 1

6 7 8 5

10 11 12 9</pre></li>

<li><pre> __________ A

3 4 1 2

7 8 5 6

11 12 9 10</pre></li>

<li><pre> _________ A

1 2 3 4

6 7 8 5

11 12 9 10</pre></li>

<li><pre> _________ A

2 3 4 1

5 6 7 8

12 9 10 11</pre></li>

<li><pre> _________ A

5 2 11 4

9 6 3 8

1 10 7 12</pre></li>

</ol>

</li>

<li>A palindrome is a string that reads the same both forward and backward.

<li>Write an expression to determine if a vector <code>V</code> is a palindrome.</li>

<li>Given that <code>V</code> is a nested vector, write an expression that will determine which of the items of <code>V</code> are palindromes.</li>

</ol></li>

<li>Given a matrix <code>M</code>, write an expression to replace the main diagonal of <code>M</code> with

<li>The number zero.</li>

<li>The character <code>'Z'</code>.</li>

<li>The character string <code>'DIAG'</code>.</li>

</ol></li>

<li>For the matrix <code>T</code>, write an expression to replace with zeros the items on the diagonal just to the right of the main diagonal.</li>

<li>Write an expression to test whether a given square matrix <code>S</code> is symmetric (that is, if <code>S[I;J]=S[J;I]</code> for all <code>I</code> and <code>J</code>.)</li>

<li>Write an expression that maps numeric vector <code>V</code> so the smallest number maps to <code>1</code>, the next smallest number maps to <code>2</code>, and so on until the largest number maps to <code>⍴V</code>. For example, the vector <code>53 47 95 6 77 78 83 13 2 69</code> should then map to the vector <code>5 4 10 2 7 8 9 3 1 6</code>.</li>

<li><code>M</code> and <code>N</code> are simple matrices having the same number of columns.

<li>Write an expression to produce a Boolean vector which is 1 when the corresponding row of <code>M</code> is also a row of <code>N</code>.</li>

<li>Write an expression to determine which rows of <code>M</code> match rows in <code>N</code>. Return the row indices of <code>N</code> as the result.</li>

</ol></li>

<li>Suppose you have the following two character vectors:

<pre> FROM ← 'ABCDEF'

TO ← 'abcdef'</pre>

Write an expression using <code>FROM</code> and <code>TO</code> that converts the character string <code>'CAB'</code> to lower case.</li>

<li>Given simple scalar <code>S</code>, write an expression to find the first occurrence of <code>S</code> in each row of a matrix. If the scalar is not present, return a number one greater than the number of columns in the matrix.</li>

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

</ol></li>

<li>State the value of each of the following expressions, given:

</ol></li>

<li>State the value of each of the following expressions, given:

<pre> AV←'ABCD ... Z'

NAMES←5 3⍴'TEETEAATEDADDAB'</pre>

<li><code>AV⍋NAMES</code></li>

<li><code>AV⍒NAMES</code></li>

<li><code>NAMES[AV⍋NAMES;]</code></li>

</ol></li>

<li>The find function (<code>⍷</code>) does not wrap around rows in searching an array. Write an expression to find a character string <code>V</code> in an array <code>A</code> even if the string wraps around in row-major order in the array. For example, searching for <code>XYZ</code> in this array:

<pre> XYZX

YZXY

ZXYZ</pre>

produces the following:

<pre> 1 0 0 1

0 0 1 0

0 1 0 0</pre></li>

<li>Write a dyadic function <code>BLANKOUT</code> whose left argument is a set of characters which, if found in the right argument character string, are to be set to blanks. Here is an example:

<pre> ‘,.’‘?!’ BLANKOUT ‘APL2 IS FUN!, ISN’‘T IT?’

APL2 IS FUN ISN T IT </pre></li>

</ol>

<h3 id="section-6.4-computation">Section 6.4 — Computation<a href="#section-6.4-computation" class="section-link">§</a></h3>

You’ve already seen some of APL2’s computational functions such as addition, power, and magnitude. This section contains further discussion of power and introduces the rest of the APL2 computational functions:

<ul>

<li>exponential</li>

<li>logarithm</li>

<li>decode</li>

<li>encode</li>

<li>factorial</li>

<li>binomial</li>

<li>trigonometric functions</li>

<li>matrix inverse</li>

<li>matrix divide</li>

</ul>

<h4 id="power-and-exponential">Power and Exponential<a href="#power-and-exponential" class="section-link">§</a></h4>

<a href="chapter2.html">Chapter 2</a> introduced the power function. Power has some interesting properties that lead to a definition of the function on nonintegers.

Suppose you take the product of two powers of the same number:

<pre> (2⋆2)×(2⋆3)

32</pre>

This result is the same as <code>2⋆5</code>. Therefore, to compute the product of powers, add the exponents:

Several interesting cases can be derived from this. In each of the examples that follow, add the exponents to determine the results:

<pre> (2⋆2)×(2⋆3)×(2⋆1)

64</pre>

This example shows that <code>2⋆1</code> is the same as <code>2</code> because <code>(2⋆2)×(2⋆3)</code> is <code>(2⋆5)</code>, which is <code>32</code>. If multiplying also by <code>(2⋆1)</code> gives <code>64</code>, then <code>(2⋆1)</code> must be <code>2</code>.

<pre> (2⋆2)×(2⋆3)×(2⋆0)

32</pre>

This example shows that any number to the zero power is <code>1</code>. <code>(2⋆2)×(2⋆3)</code> is <code>(2⋆5)</code>, which is <code>32</code>. If multiplying by <code>(2⋆0)</code> also gives <code>32</code>, then <code>(2⋆0)</code> must be <code>1</code>.

Power is not limited to nonnegative integer arguments. Here’s an expression with a negative exponent:

<pre> (2⋆2)×(2⋆3)×(2⋆¯2)

8</pre>

<code>(2⋆2)×(2⋆3)</code> is the same as <code>(2⋆5)</code>, which is <code>32</code>. If multiplying by <code>(2⋆¯2)</code> gives <code>8</code>, then <code>(2⋆¯2)</code> must be the same as dividing by <code>(2⋆2)</code>, which is <code>4</code>. Thus, a negative exponent implies division by the same quantity with the exponent made positive.

Suppose that the exponents are not integers:

<pre> (2⋆.1)×(2⋆.5)×(2⋆.4)

2</pre>

The exponents add to <code>1</code> so the answer equals <code>2⋆1</code>. Use of fractional exponents gives rise to some common special cases of power. Consider this:

<pre> (2⋆.5)×(2⋆.5)

2</pre>

Again, the exponents sum to <code>1</code>. But what is <code>2⋆.5</code>? It is a number that when multiplied by itself gives <code>2</code>. In mathematics, such a number is a square root. APL2 has no special square root function. It is just a special case of power with a right argument of one-half:

<pre> 2⋆.5

1.414213562</pre>

You may have heard that you cannot take the square root of a negative number. Try it on your system:

You might get one of two responses. This response means that your implementation supports only real numbers:

<pre>DOMAIN ERROR

¯4⋆.5

^ ^</pre>

This response means that your implementation supports complex numbers:

If you get this answer, enter the following:

<pre> 0J2 × 0J2

¯4</pre>

This result shows that <code>0J2</code> is the square root of <code>¯4</code>. The number <code>0J2</code> is called a complex number. In mathematics, a complex number is often written as an expression like 0<code>+</code>2i. Complex numbers are not discussed further in this book.

You indicate cube roots by using power with a right argument of one-third:

<pre> 64⋆÷3

4</pre>

In general, in APL2, enter <code>A⋆÷N</code> to take the <code>N</code>th root of a number <code>A</code>.

You saw, in the discussion of floor in <a href="chapter2.html">Chapter 2</a>, that you can compute a 5% interest one time as follows:

<pre> AMOUNT←150.20 331.35 331.25

AMOUNT×1.05

157.71 347.9175 347.8125</pre>

Suppose one year later you get 5% interest again on your amount. This is, again, 1.05 times the previous new amount:

<pre> AMOUNT×1.05×1.05

165.5955 365.313375 365.203125</pre>

Instead of using multiplication, you can compute the new amount using power:

<pre> AMOUNT×1.05⋆2

165.5955 365.313375 365.203125</pre>

Although there is not much difference between using a power of 2 and multiplication, the difference becomes significant if you require more repetitive multiplications. Suppose you get 5% every year for four years. Using power, you can compute the amount after four years with no more typing than computing the interest for two years:

<pre> AMOUNT×1.05⋆4

182.5690388 402.7579959 402.6364453</pre>

You may want to know your balance on each account at the end of each of the four years so you can see how your money grows. These are interest multiplication factors:

<pre> (1.05)(1.05⋆2)(1.05⋆3)(1.05⋆4)

1.05 1.1025 1.157625 1.21550625</pre>

These can be computed more compactly like this:

<pre> 1.05⋆⍳4

1.05 1.1025 1.157625 1.21550625</pre>

Now you want to multiply each amount by each factor. That is, you want all combinations of amounts with factors. You should remember from <a href="chapter5.html">Chapter 5</a> that all combinations means outer product in APL2. Thus, the desired computation is expressed as follows:

<pre> AMOUNT ∘.× 1.05⋆⍳4

157.71 165.5955 173.875275 182.5690388

347.9175 365.313375 383.5790438 402.7579959

347.8125 365.203125 383.4632813 402.6364453</pre>

Finally, you can round these amounts so they are easier to study:

<pre> .01×⌊.5+100×AMOUNT ∘.× 1.05⋆⍳4

157.71 165.6 173.88 182.57

347.92 365.31 383.58 402.76

347.81 365.2 383.46 402.64</pre>

When power is used without a left argument, it is exponential. Exponential is the same as power with a left argument of <code>2.718281828</code> (rounded to 10 places).

<pre> ⋆2

7.389056099</pre>

The constant 2.718281828 is often represented in mathematics by the letter e.

You can use power with an integer exponent and with a fractional exponent to express the famous Pythagorean Theorem: “In a right triangle, the length of the hypotenuse is the square root of the sum of the squares of the legs”:

</center>

Suppose that the legs are of lengths <code>3</code> and <code>4</code>. The computation of the hypotenuse is follows:

<pre> LEGS← 3 4

(+/LEGS⋆2)⋆.5

5</pre>

<h4 id="logarithm">Logarithm<a href="#logarithm" class="section-link">§</a></h4>

You’ve just seen that, in a limited sense, power lets you compute products by doing addition (of the exponents). Addition is easy because even if you don’t know the algorithm for it, you can compute the sum of 2 and 3 with a ruler by measuring a string of length 2 laid next to a string of length 8. The famous mathematician Napier discovered a way to do the same thing for multiplication with a function called logarithm.

Napier marked off a ruler so the markings represented the exponents. Now adding lengths is like adding exponents and that is multiplication (as seen in the power section). Napier used ivory bars that became known as “Napier’s bones.” Robert Bissaker adapted the idea and built a ruler called a slide rule because it includes a sliding section to make addition of lengths easy. It was the mainstay of engineering calculations until the invention of the electronic calculator.

APL2 implements Napier’s function with the symbol <code>⍟</code> and calls it logarithm. Logarithm is certainly less familiar to most people than addition and subtraction. It is, however, just a function that, given one number, produces another number. All you need to know is what you can do with the function.

Here are some base-10 logarithms:

<pre> 10⍟100

10⍟325

2.511883361

10⍟1000

10⍟10000

4</pre>

Logarithms to the base 10 are sometimes called common logarithms. Logarithm is the inverse of the power function:

<pre> N⍟(N⋆X) is X for N not zero

10⋆10⍟10000

10000</pre>

In cases where the result is an integer, it is easy to see that logarithm is the inverse of power because, for example, 4 is the power of 10 that would give 10000.

Every number greater than or equal to 100 but less than 1000 has a logarithm with 2 as an integer part. Given this fact, logarithm can be used to compute the number of digits in any decimal number <code>N</code>. When you are programming a report, you can use the computation of the number of digits to determine how much space on a line some data will take. You can compute the number of integer digits by finding the integer part of <code>1+10⍟N</code>:

<pre> 1+10⍟100

1+10⍟325

3.511883361</pre>

Notice that leading zeros on a number have no effect:

<pre> 1+10⍟00000325

3.511883361</pre>

By convention, in a decimal number, leading zeros are not written unless there are no other digits.

You already know of a function that takes the integer part of a number—it’s floor. The following is a more complete expression for the number of digits in a number:

<pre> N←345.76

10⍟N

2.53877475

⌊1+10⍟N

3</pre>

To be completely general, this expression must be augmented in two ways. First, when counting digits in a number, the sign of the number is not relevant. You should apply the expression only to positive numbers. Here is the expression applied only to the magnitude of a number:

<pre> ⌊1+10⍟∣N

3</pre>

Second, zero is a special case. It is the only number that must be written with a leading zero. Otherwise, it would be written as an empty string of digits. An empty string would, in fact, be more correct, but it is difficult to distinguish it from no number at all. Therefore, we want to count one digit if the number is zero. Here, then, are two expressions for counting the number of integer digits:

<pre> ⌊1+10⍟∣N+N=0

⌊1+10⍟1⌈∣N

3</pre>

The monadic natural logarithm (<code>⍟</code>) function is the inverse of the monadic power functions:

The following is an example:

<pre> 2⋆6

2⍟2⋆6

⋆6

403.4287935

⍟⋆6

6</pre>

<h4 id="decode">Decode<a href="#decode" class="section-link">§</a></h4>

In <a href="chapter5.html">Chapter 5</a>, you saw inner product used to convert hours, minutes, and seconds to seconds:

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

8130</pre>

The left argument had to be computed. Decode (<code>⊥</code>) is like inner product. (In fact, all the shape rules are identical.) The left argument of decode is, however, the units of measurement, not the conversion factors. Thus decode can achieve the same result as the above inner product as follows:

<pre> 24 60 60⊥2 15 30

8130</pre>

The left argument indicates 24 hours in a day, 60 minutes in an hour, and 60 seconds in a minute. Given a vector as an argument to decode, the corresponding argument to inner product is computed as follows:

Here is an example:

<pre> ⌽1,×\⌽1↓24 60 60

3600 60 1</pre>

From the formula, you can tell that the leftmost number in the left argument is not used and could be anything. The discussion of encode gives the reason for including the <code>24</code>.

In general, the following identity relates decode and inner product:

You might think of time measurement as a counting system, or a number system. Seconds count from 0 to 59; then the minutes number increments, and the seconds go back to zero. When the minute count exceeds 59, hours increment. When hours exceed 23, days increment. (A common timekeeping system counts from 1 to 12 for hours, then increments a half-day counter, not from 0 to 1, but from AM to PM. This system takes a little more programming to support.)

A number system that uses a different value in each position is a mixed radix, or a mixed base, system. More uniform number systems have the same number of values in each position. By far the most common such number system is the Arabic, or decimal number, system based on 10 values in each position. Other common bases for number systems are 2, 8, and 16 (binary, octal, and hexadecimal). These are used mostly by computers. People use base 10 presumably because when the Arabs started using it, people had ten fingers. It’s too bad that they didn’t have twelve fingers because twelve has twice as many even divisors as ten (2, 3, 4, and 6 compared to 2 and 5). This would have reduced the number of fractions in everyday arithmetic.

APL2 numeric input and output is exclusively base 10.

If you have the digits of a decimal number, you can compute the scalar number they represent using decode:

<pre> 10 10 10 10⊥1 9 8 8

1988</pre>

If the number system is not mixed radix, you need not write a vector left argument:

<pre> 10⊥ 1 9 8 8

1988</pre>

This makes alternate number bases easy to convert to decimal. Here are conversions from bases 2 and 16:

<pre> 2⊥0 1 0 1

16⊥ 0 1 9 15

415</pre>

Any number on the left yields an answer:

<pre> 137⊥1 2 5 7

2609583

1.1⊥1 2 5 7

16.251</pre>

Base 137 is unreasonable and base 1.1 is strange. There is, however, another interpretation of decode. Consider the following polynomial:

<math>

<mrow>

<msup>

</msup>

<msup>

</msup>

</mrow>

</math>

</center>

The following expression evaluates the polynomial when <code>X</code> is 137:

<pre> +/(137⋆3) (137⋆2) 137 1 × 1 2 5 7

2609583</pre>

You can also write the evaluation of a polynomial as an inner product expression:

<pre> (137⋆3) (137⋆2) 137 1 +.× 1 2 5 7

2609583</pre>

Finally, you can write the evaluation of a polynomial as a decode expression:

<pre> 137⊥1 2 5 7

2609583</pre>

On higher-rank arrays, decode acts like inner product and applies the vector definition between rows from the left argument and columns from the right argument in all combinations:

<pre> (2 3⍴24 60 60 10 10 10)⊥3 2⍴2 9 15 8 30 6

8130 32886

380 986</pre>

<h4 id="encode">Encode<a href="#encode" class="section-link">§</a></h4>

You may think of encode (<code>⊤</code>) as doing the reverse operation of decode. (It’s not, correctly speaking, an inverse.) Given the total number of seconds, encode can compute the number of hours, minutes, and seconds:

<pre> 24 60 60 ⊤8130

2 15 30</pre>

Notice that this example uses the same left argument the first decode example used. Here, however, the 24 is necessary to limit the hours figure to the range 0 to 23. Here’s an example where the number of seconds is more than 24 hours:

<pre> 24 60 60 ⊤813000

9 50 0</pre>

Even though 813,000 seconds is more than 24 hours, the answer reflects time less than 24 hours. Two ways are available for you to capture the amount of time lost in this computation. First, you can add another item in the left argument to represent days of the week:

<pre> 7 24 60 60 ⊤813000

2 9 50 0</pre>

This method works only with a right argument that contains less than a week’s worth of seconds.

Second, APL2 has a way to let one position in the result of an encode get arbitrarily large. A zero in the left argument means “accept any number in the corresponding position in the result”:

<pre> 0 60 60 ⊤ 813000

225 50 0</pre>

Numbers in the abstract can be arbitrarily large. An indefinite number of digits might be required to represent a number. When you encode numbers, you must know how many digits you want to represent. In a given problem, you usually know.

The following examples use encode to reverse the corresponding decode examples:

<pre> 10 10 10 10⊤1988

1 9 8 8

2 2 2 2 27⊤5

0 0 1 0 1

(4⍴16)⊤415

0 1 9 15</pre>

If you are working with polynomials, encode takes the value of a polynomial and the value of the variable and computes a set of coefficients:

<pre> 137 137 137 137 ⊤26098583

1 2 5 7</pre>

On higher-rank arrays, encode has the same shape rules as outer product and applies columns from the left argument against scalars from the right argument in all combinations:

<pre> 4 2⍴ 10 16

10 16

(4 2⍴ 10 16)⊤137

0 0

1 0

3 8

7 9</pre>

Notice that the encoding is along the leftmost axis of the result.

For more detailed information on encode with higher-rank arrays, see the documentation that comes with your system.

<h4 id="factorial-and-binomial">Factorial and Binomial<a href="#factorial-and-binomial" class="section-link">§</a></h4>

Monadic factorial and dyadic binomial are functions you can use to figure out combinatorial problems. These two functions are discussed in this section.

<h5 id="factorial">Factorial<a href="#factorial" class="section-link">§</a></h5>

Suppose you have a game consisting of five unique pieces labeled <code>A</code> through <code>E</code> which are arranged in a row. Here is one arrangement of the five pieces:

<pre> DISPLAY 'ACBED'

.→----.

|ACBED|

'-----'</pre>

How many different ways can you arrange these five pieces? For the leftmost position, you could choose any of the five pieces. For the second from the left position, you could choose any of the remaining four pieces. The third position could contain any of the remaining three pieces. The fourth position any of the remaining two pieces. And there is only one choice for the fifth position. The total number of possible arrangements is:

<pre> 5×4×3×2×1

120

×/⍳5

120</pre>

The monadic factorial function computes this result directly:

<pre> !5

120</pre>

The number of combinations possible when the pieces are not all distinct can also be computed easily. Suppose of the five pieces, three have the same label:

<pre> DISPLAY 'ABAAC'

.→----.

|ABAAC|

'-----'</pre>

There are still 120 arrangements but some look the same as others. For fixed <code>B</code> and <code>C</code>, you could choose any <code>A</code> for the first position, any of the remaining two for the third position, and have only one choice for the fourth position. Therefore, the number of ways to select the <code>A</code>’s is <code>3×2×1</code> which is <code>!3</code>. This is true for every choice of position for <code>B</code> and <code>C</code>, so the number of distinct arrangements is the total number of arrangements divided by the number of arrangements not distinguishable:

<pre> (!5)÷!3

20</pre>

If you have six white marbles and four black ones, you compute the number of distinct linear arrangements:

<pre> (!10)÷(!6)×(!4)

210

(!10)÷×/!6 4

210</pre>

Note: factorial is related to the gamma function of higher mathematics as follows:

<pre> !A <--> gamma A+1</pre>

This relationship is used to define factorial on noninteger and non-positive numbers. The gamma function is not discussed further in this book.

<h5 id="binomial">Binomial<a href="#binomial" class="section-link">§</a></h5>

Suppose you have seven distinct pieces and you select three of them. How many ways can you select three things from a collection of seven? You can choose any of the seven for the first selection, any of the remaining six for the second selection, and any of the remaining five for the third selection. Thus, the number of selections is:

<pre> 7×6×5

210</pre>

Factorial 7 is <code>7×6×5×4×3×2×1</code>. Clearly, if you divide by <code>4×3×2×1</code> (which is <code>!7−3</code>), you get the desired result:

<pre> (!7)÷!7−3

210</pre>

In general, to select <code>R</code> things in order from a set of <code>L</code> things, you evaluate the following expression:

If the order of the selected items doesn’t matter when selecting three items from a set of seven items, there are <code>!3</code> different arrangements which contain the same three pieces. Dividing by the number of arrangements giving the same pieces gives the count of the number of different selections ignoring order:

<pre> (!7)÷(!7−3)×!3

35</pre>

Selecting items from a collection without regard to order is a common operation. The dyadic binomial function computes this more compactly:

<pre> 3!7

35</pre>

Formally, binomial is defined for all numbers by the following equation:

Note: Binomial is related to the mathematical beta function.

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

APL2 has a full set of trigonometric, hyperbolic, and pythagorian functions whose derivations are based on the analysis of circles. If you have no current use for these functions, you can skip this section.

<h5 id="pi-times">Pi-times<a href="#pi-times" class="section-link">§</a></h5>

A fundamental constant related to circles is pi (π), which is the number of circle diameters equal to the circumference of a circle. APL2’s monadic primitive pi-times (<code>○</code>) computes products of pi:

<pre> ○1

3.141592654

○3

9.424777961</pre>

The circumference of a circle with radius <code>R</code> is computed with pi-times as follows:

In science and mathematics, angles are often analyzed by looking at them in a right triangle imbedded in a unit circle with the vertex of the angle in question at the center of the circle:

</center>

The angle θ is normally measured by measuring the length of the segment of the circumference it intersects. If it intersects a length equal to the radius of the circle, the angle has a measure of one radian. A full circle, therefore, contains 2<code>×</code>pi radians. People often measure angles in degrees, and a circle has 360 degrees. The conversion of degrees to radians derives from the fact that 360 degrees is 2<code>×</code>pi radians. Thus, one degree is (pi radians)<code>÷</code>180.

Using pi-times, the following expressions convert 45 degrees to radians:

<pre> 45×○÷180

0.7853981634

○45÷180

0.7853981634</pre>

<h5 id="circular-functions">Circular Functions<a href="#circular-functions" class="section-link">§</a></h5>

APL2 includes 25 functions related to circles. Rather than assign each of them a unique symbol, APL2 packages the entire set in the dyadic; circular function (<code>○</code>), where the left argument integer specifies which monadic function is desired. The following table summarizes the circular functions available in APL2 Table entries 8-12 apply to complex numbers.

<table>

<caption>Table 6.4 Circular Functions</caption>

<thead>

<th style="text-align: left;">Negative <code>L</code></th>

<th style="text-align: left;">Positive <code>L</code></th>

</tr>

</thead>

<tbody>

<tr>

</tr>

<tr>

</tr>

<tr>

<td class="l r" style="text-align: left;">Arc cosine <code>R</code></td>

<td class="l r" style="text-align: left;">Cosine <code>R</code></td>

</tr>

<tr>

<td class="l r" style="text-align: left;">Arc tangent <code>R</code></td>

<td class="l r" style="text-align: left;">Tangent <code>R</code></td>

</tr>

<tr>

</tr>

<tr>

<td class="l r" style="text-align: left;">Inverse hyperbolic sine <code>R</code></td>

<td class="l r" style="text-align: left;">Hyperbolic sine <code>R</code></td>

</tr>

<tr>

<td class="l r" style="text-align: left;">Inverse hyperbolic cosine <code>R</code></td>

<td class="l r" style="text-align: left;">Hyperbolic cosine <code>R</code></td>

</tr>

<tr>

<td class="l r" style="text-align: left;">Inverse hyperbolic tangent <code>R</code></td>

<td class="l r" style="text-align: left;">Hyperbolic tangent <code>R</code></td>

</tr>

<tr>

</tr>

<tr>

</tr>

<tr>

<td class="l r" style="text-align: left;"><code>+R</code> (conjugate)</td>

</tr>

<tr>

<td class="l r" style="text-align: left;">Imaginary <code>R</code></td>

</tr>

<tr>

<td class="l r b" style="text-align: left;">Phase <code>R</code></td>

</tr>

</tbody>

</table>

</center>

Note: If complex numbers are not implemented on your system, the positive numbers above <code>7</code> and the negative numbers below <code>¯7</code> will not be available.

Many of the relationships between these functions can be seen by looking at a triangle in a unit circle:

</center>

For example, you may have seen this trigonometric equation:

<math>

<mrow>

<msup>

</msup>

<msup>

</msup>

</mrow>

</math>

</center>

This equation is tested in APL2 at 30 degrees by the following expression:

<pre> +/(1 2○○30÷180)⋆2

1</pre>

If you solve for sine in the equation, you get the following:

<math>

<mrow>

<msqrt>

<mrow>

<msup>

</msup>

</mrow>

</msqrt>

</mrow>

</math>

</center>

This is the value computed by <code>0○</code>. Thus, given a value of sine, you can use <code>0○</code> to solve for the value of cosine for the same angle.

<h4 id="matrix-inverse">Matrix Inverse<a href="#matrix-inverse" class="section-link">§</a></h4>

A function f is an inverse of function g if applying f to the result of g gives an identity of some kind. For example, in ordinary arithmetic, multiplication and division are inverses because a number times its reciprocal is 1 which is the identity of multiplication:

<pre> N←÷20

0.05

N×20

1</pre>

Multiplication and division are scalar functions and extend to arrays like all scalar functions.

<pre> N←÷20 10 5

0.05 0.1 0.2

N×20 10 5

1 1 1</pre>

You’ve seen inner product with operands <code>+</code> and <code>×</code> in <a href="chapter5.html">Chapter 5</a>. When applied to simple scalars, inner product with these operands is like multiplication:

<pre> N+.×20

1</pre>

APL2 has a <code>⌹</code> function which is like reciprocal on simple scalars and is the inverse of <code>+.×</code>:

<pre> N←⌹20

0.05

N+.×20

1</pre>

When applied to non-scalars, <code>+.×</code> and <code>⌹</code> are not scalar functions:

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

14 ¯140 168

¯40 640 ¯840

27 ¯540 756

⌹I

0.3333333333 0.1666666667 0.1111111111

0.08333333333 0.06666666667 0.05555555556

0.04761904762 0.04166666667 0.03703703704</pre>

Inner product with <code>+</code> and <code>×</code> is the algebraic matrix product, and <code>⌹</code> is the algebraic matrix inverse which is APL2’s matrix inverse function. The <code>+.×</code> inner product of any array with its matrix inverse is the identity matrix with <code>1</code>’s along the main diagonal and <code>0</code>’s everywhere else:

<pre> (⌹I)+.× I

1 0 0

0 1 0

0 0 1</pre>

Computation of a matrix inverse is a complicated procedure that is subject to numerical errors. The answer given by your APL2 implementation may not lead to a perfect identity matrix for the preceding example. For example, if your computer can store 16 digits, <code>1E¯16</code> or <code>1E¯15</code> for off-diagonal items are close to zero when compared to the <code>1</code>’s on the diagonal.

Matrix inverse must be applied to a matrix whose rows are linearly independent (that is, you can’t combine some rows by addition, subtraction, and multiplication by a scalar and produce one of: the other rows). If the rows are not linearly independent, the matrix is called singular and <code>⌹</code> produces a <code>DOMAIN ERROR</code>.

You may apply matrix inverse to a non-square matrix that has more rows than columns as long as there are as many independent rows as there are columns. In this case, a left inverse is produced:

<pre> II← 5 2⍴1 1 1 2 1 3 1 4 1 5

⌹II

0.8 0.5 2.000000000E¯1 ¯0.1 ¯0.4

¯0.2 ¯0.1 ¯4.678201316E¯17 0.1 0.2

(⌹II)+.×II

1 0

0 1</pre>

More than one answer which would be a left identity and produce an identity matrix is possible for the result of <code>⌹</code> in the above example. APL2 produces the result that, for <code>M←⌹A</code> and <code>ID←M+.×A</code>, gives the smallest number in this equation:

Producing the result in this way is called a least squares fit.

<h4 id="matrix-divide">Matrix Divide<a href="#matrix-divide" class="section-link">§</a></h4>

Matrix inverse can be used to solve systems of linear equations. Here is an example:

<math>

<mrow>

<mtr>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

</mtr>

<mtr>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

</mtr>

<mtr>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

<mtd>

</mtd>

</mtr>

</mtable>

</mrow>

</math>

</center>

These equations are satisfied when <code>X</code> is 1, <code>Y</code> is 2, and <code>Z</code> is 0. Here is the solution using matrix inverse:

<pre> SE←3 3⍴ 1 1 1 4 2 1 9 3 1

1 1 1

4 2 1

9 3 1

(⌹SE)+.×3 8 15

1 2 0</pre>

Matrix divide (<code>⌹</code>) does this computation in a single operation, where the right argument is a matrix of coefficients and the left argument is a vector of results for the equations:

<pre> 3 8 15⌹SE

1 2 ¯2.664535259E¯15</pre>

If the right argument has more rows than columns, the solution APL2 chooses is one that, for <code>S←B⌹A</code>, minimizes this equation:

Producing the result in this way is also called a least squares fit.

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

<ol>

<li>Suppose you invested one penny in the year 1776 and received 5% interest each year (no rounding). How much money would you have in 1987, 211 years later? Suppose you invested 50 pennies at the same rate. How much money would you have in 1987?</li>

<li>You decide to make a trip around the world by balloon and you take with you $100 (USD). You never spend any money, but every time you cross a national boundary, you convert your money into the local currency. You are charged a 5% fee each time you convert money.

<li>Write an expression that computes the amount of money you have after entering the sixth country. Hint: Treat the service charge as negative interest.</li>

<li>It costs one dollar to send a telegram back home. What is the largest number of countries you can visit before sending home for more money? Hint: Use interval (<code>⍳</code>) for experimentally locating the time when your money would drop below one dollar.</li>

</ol></li>

<li>Notebooks come in ring sizes that increment by .5 inches. Every .5 inch can accommodate 100 sheets of paper. Define a function called <code>SIZE</code> that, given a vector of the number of sheets <code>S</code> in a set of manuals, returns the size binder to purchase for each manual.

Here is a sample execution:

<pre> SIZE 200 250 263 310

2 2.5 3 3.5</pre></li>

<li>Write an expression to express an arbitrary integer in base 2. For example, applied to the number 17, you should get <code>1 0 0 0 1</code> Hint: Use a base-2 logarithm to compute the number of digits.</li>

<li>You saw indexing used to produce a histogram. Here is the sales data for a for each month of the year 1987:

<pre> AMPL← 1005 1011 1017 1009 1023 1024 1021

AMPL←AMPL,1029 1031 1029 1035 1037</pre>

<li>What is the total number of sales in 1987?</li>

<li>What was the largest number sold in a month?</li>

<li>If one sale represents $137 in profit, what is the total profit for the year?</li>

<li>If each sale is really a lease with a monthly rental, then a sale in January is worth more than a sale in December. What is the total profit for the year, if each sale generates $13 per month starting in the month it is sold?</li>

<li>The sales manager wants to see a histogram of this data. You could easily use outer product and indexing to plot the graph:

But a plot over a thousand lines long is not desirable. Scale the data so all of it falls in the range 0 to 20. Using indexing, plot a histogram of the resulting data.</li>

<li>The marketing manager wants to show more dramatic growth with the data from part e. Plot just the top of the histogram by subtracting 1000 from the data and then scaling to the range 0 to 20.</li>

</ol></li>

<li>Write an expression to convert an integer to a character string that represents an eight-digit signed hexadecimal (base 16) number. Here is an example:

<pre> 12 converts to 0000000C

¯1 converts to FFFFFFFF</pre></li>

<li>Write an expression to convert a character string that represents a hexadecimal number to a signed integer.</li>

<li>Suppose you have a perfectly spherical globe. This globe has a radius of 45 prats (a unit of measure used nowhere in the civilized world).

<li>If you tie a string around the equator on the globe, write an expression to determine the length of the string (ignoring the extra string it takes to tie the knot).</li>

<li>If you want the string to be off the surface of the globe 10 prats over the equator (assuming you have some way of suspending it there), how much string would you have to add?</li>

<li>Suppose the planet Xtric is a perfect sphere with a string wrapped tightly around its equator. If you want the string to be 10 prats off the surface over the equator, how much string would you have to add, assuming that the radius of Xtric is 45,000,000 prats?</li>

</ol></li>

<li>Assume the earth revolves about the sun in a circular orbit. If the distance from the earth to the sun is <code>DIST</code> miles, and the earth takes 364.25 days to complete one revolution, at what rate in miles per second is the earth traveling about the sun?</li>

<li>The article “Engineering Voyager 2’s Encounter with Uranus” in the November 1986 issue of Scientific American described the remarkable engineering feat of sending a satellite through the solar system past Uranus. As it passed the planet, the satellite transmitted 6000 images of Uranus back to earth. Each of these images consisted of 800 rows of 800 pixels. Because each pixel could represent one of 256 brightness levels, there were 8‘b1ts per pixel, or 5,120,000 bits per image. The data transmission rate was 21.6 kilobits per second. Determine the amount of time that was required to transmit all the images back to the earth. Give this time in terms of weeks, days, minutes, and seconds.</li>

<li>In hilly areas, road signs indicate the grade of the road with a pair of numbers such as 1:7. In this pair a:b, the first number a defines the amount of drop (or climb) vertically that occurs while moving horizontally b units. Write a function to accept a pair of grade numbers and determine the angle in degrees from the horizontal of the grade.</li>

<li>Evaluate the following expressions:

</ol></li>

<li>Suppose one object is traveling at velocity <code>X</code> and another is traveling at velocity <code>Y</code> in the opposite direction. If the objects are moving slow enough, you can just add velocities. If they are on the earth, however, they begin to travel around the curvature of the earth and their relative velocity is less than the sum of their velocities. In space, the relative velocity of two objects traveling in opposite directions is controlled by Lorentz’s equation:

<math>

<mrow>

<mfrac>

<mrow>

</mrow>

<mrow>

<msqrt>

<mrow>

<mfrac>

<mrow>

</mrow>

<mrow>

<msup>

</msup>

</mrow>

</mfrac>

</mrow>

</msqrt>

</mrow>

</mfrac>

</mrow>

</math>

</center>

where <code>C</code> is the speed of light (300,000 meters per second).

Suppose the two velocities are represented in the vector <code>V</code>:

<li>Write an expression to compute the relative velocity.</li>

<li>Suppose that each object is traveling at half the speed of light. What is their relative velocity?

By analogy with objects traveling on the earth, Einstein reasoned that, since the relative velocity was less than the sum, space was curved.</li>

</ol></li>

<li>State the value of each of the following expressions:

</ol></li>

<li>State the value of each of the following expressions:

</ol></li>

</ol>

<h3 id="section-6.5-generating-random-numbers">Section 6.5 — Generating Random Numbers<a href="#section-6.5-generating-random-numbers" class="section-link">§</a></h3>

You saw an encoding of a message that replaced each letter by its position in the roman alphabet. Anyone might guess your method if you encode a message this way. A better way to encode a message would be to use a random arrangement of the alphabet. This section introduces some functions that can be used in this solution.

Deal (<code>?</code>) generates random numbers. The expression <code>A?B</code> generates <code>A</code> random selections from the set of integers <code>⍳B</code> without replacement (that is, no number occurs twice):

<pre> 5?10

1 3 6 2 4

5?10

3 1 9 5 2</pre>

The function roll (<code>?</code>) generates one random integer for each integer in the argument. Here is an example:

<pre> ? 10 10 10 10 10

1 5 1 2 4</pre>

Each selection is independent, so duplicate integers can occur.

You can generate a random roll of a pair of dice as follows:

<pre> ?6 6

3 5</pre>

Here’s a way to encode a message using a random permutation of the alphabet A through Z plus blank:

<pre> ALPH1←ALPH[27?27]

ALPH1

XGNLRUZVB ICOYTDKMQEPJAHSFW</pre>

The dyadic function deal (<code>?</code>) computes 27 (left argument) different random integers from 1 to 27 (right argument). If you try this at your computer, you will probably get different numbers because deal does not necessarily produce the same random selection in two consecutive executions.

Using this permuted alphabet, you can get integers that are not related to the position of letters in the roman alphabet:

<pre> NUM1←ALPH1⍳'SECRET MESSAGE'

NUM1

25 20 12 5 20 15 10 18 20 25 25 23 2 20</pre>

If you would prefer to see some nonsense letters instead of numbers you can turn the integers into characters:

<pre> MESS1←ALPH[ALPH1⍳'SECRET MESSAGE']

MESS1

YTLETOJRTYYWBT</pre>

If you know the encoding alphabet <code>ALPH1</code>, the code is easy to break by using indexing:

<pre> ALPH1[NUM1]

SECRET MESSAGE

ALPH1[ALPH⍳MESS1]

SECRET MESSAGE</pre>

Now you have an encoding that is not so easy to guess. There are <code>!27</code> different possible alphabets that could arise from the random selection of 27 items:

<pre> !27

1.088886945E28</pre>

Factorial determines the different possible alphabets because there are 27 choices for the substitution for <code>'A'</code>, then 26 choices for the substitution for <code>'B'</code>, and so forth.

<h4 id="exercises-for-section-6.5">Exercises for Section 6.5[<a href="answers.html#section-6.5-generating-random-numbers">Answers</a>]<a href="#exercises-for-section-6.5" class="section-link">§</a></h4>

<ol>

<li>In each of the following sets of expressions, one expression will satisfy the given statement. Determine which one it is.

<li>Select with replacement two random integers chosen from the set of integers <code>⍳10</code>.

<ol>

</ol></li>

<li>Select without replacement two integers chosen from the set of integers <code>⍳10</code>.

<ol>

</ol></li>

<li>Select with replacement two random integers chosen from the set of integers between <code>¯5</code> and <code>5</code>, excluding both <code>¯5</code> and <code>5</code>.

<ol>

</ol></li>

<li>Select without replacement three random integers chosen from the set of integers between <code>¯5</code> and <code>5</code>, inclusive.

<ol>

</ol></li>

<li>Write an expression to represent each of the following statements:

<li>The deal of five cards from a standard deck of cards.</li>

<li>A prime number selected at random from the first six prime numbers.</li>

<li>A vector such that its dimension is no greater than 10, and each item is a random integer less than or equal to 25.</li>

<li>A matrix of three rows and four columns containing positive random integers all less than 100.</li>

<li>A two-decimal place random number between 0 and 1. Both 0 and 1 are to be excluded.</li>

</ol></li>

<li>Given a vector of names <code>NAMES</code>, write an expression for each of the following:

<li>Select a name at random to assign to do dishes.</li>

<li>Rearrange the names arbitrarily for a chore list. Test your expressions on the following vector:

<pre> NAMES← 'ANNE' 'STACY' 'SCOTT' 'DAVID'</pre></li>

</ol></li>

</ol>

<tr>

[<a href="chapter5.html"><code>←</code></a>]

</td>

[<a href="contents.html"><code>↑</code></a>]

</td>

[<a href="chapter7.html"><code>→</code></a>]

</td>

</tr>

</table>

</footer>

View this page on the web

View page source