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

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

Chapter 1: Working with APL2

Chapter

<div>

</div>

<h2>Working with APL2</h2>

“Working with APL2” introduces some of APL2’s most important concepts. You start with simple computations. You learn how to represent data and how to perform computations on collections of data called arrays. Your APL2 work requires an APL or APL2 keyboard like the one shown. This keyboard provides the alphabetic characters and the special APL2 symbols.

<figcaption>Keyboard for APL2</figcaption>

</figure>

</center>

The arithmetic symbols you use in <a href="#section-1.1-doing-ordinary-arithmetic">Section 1.1</a> are all on the keyboard’s top row.

<h3 id="section-1.1-doing-ordinary-arithmetic">Section 1.1 — Doing Ordinary Arithmetic<a href="#section-1.1-doing-ordinary-arithmetic" class="section-link">§</a></h3>

In this section, you learn how to enter numbers and how APL2 displays numbers. You also learn some simple operations on numbers. With the information in this section, you will be able to use APL2 like a calculator.

If you are at a terminal, try out the examples as they arise.

<h4 id="simple-arithmetic">Simple Arithmetic<a href="#simple-arithmetic" class="section-link">§</a></h4>

One of the fundamental operations of APL2 is the function. A function applies to some data and produces some new data.

Here are examples of five basic arithmetic functions supplied with APL2:

<pre> 10+5 <---addition

10−5 <---subtraction

10×5 <---multiplication

10÷5 <---division

−2 <---negation

¯2</pre>

APL2 prompts you for input by indenting six spaces. When you type something and press the enter key (or return key or send key or whatever key signals end of input on your terminal), APL2 executes the expression you entered and, starting at the left margin, displays the result of the computation. The values written next to the function symbols are the arguments of the function.

Addition and subtraction give the results you expect. Unlike many other computer languages, APL2 uses the traditional mathematical symbols <code>×</code> and <code>÷</code> for multiplication and division. (Some programming languages use <code>⋆</code> and <code>/</code> for these functions. In APL2, <code>⋆</code> and <code>/</code> have other meanings.)

Notice that the subtraction and negation functions share the same symbol. Most APL2 functions may be used with either one or two arguments.

<h4 id="numbers">Numbers<a href="#numbers" class="section-link">§</a></h4>

APL2 has some simple rules for entering and displaying numbers.

You represent integers by a string of decimal digits like this:

<pre> 1

25</pre>

Numbers with fractional parts are represented with a decimal point separating the integer and fractional portions like this:

<pre> .1

2.3500

95.6372287356</pre>

How APL2 displays these numbers is not necessarily the way you enter them. If the number has no integer part, APL2 displays a leading zero. APL2 does not display trailing zeros on fractions.

Here are the above numbers displayed from APL2:

<pre> .1

0.1

2.3500

2.35

95.6372287356

95.63722874</pre>

Notice that, for display, APL2 rounds the last result in the tenth digit.

Some numbers, when written in decimal notation, require an infinite number of digits (for example, the fraction one-third). If there are more than 10 significant digits in a number, APL2 displays only 10 digits.

You may enter very large or very small numbers in exponential or <code>E</code>-notation. The <code>E</code> stands for “times 10 to the.” You might write the integer 123 followed by 45 zeros in <code>E</code>-notation as:

APL2 displays such numbers with a single integer digit and an appropriate fractional part:

<pre> 123E45

1.23E47</pre>

Negative numbers are represented by prefixing the number with an overbar (¯):

<pre> ¯1

¯25

¯95.6372287356</pre>

Unlike arithmetic notation, APL2 does not use the same symbol for the property of negativeness and for the operations negation and subtraction. When you see an overbar (<code>¯</code>) on a number, it means that the number is negative. If you see a midbar (<code>−</code>) before a number, it means that something is being done to the number (subtraction if there is a number on the left, and negation if there is not).

<pre> ¯25 <---a negative 25

−25 <---negation of positive 25

100−25 <---difference of 100 and 25

−¯25 <---negation of a negative 25</pre>

APL2 does not recognize some conventions for writing numbers. For example, the following are incorrect ways to enter the number 123456789.123:

<ul>

<li><code>123,456,789.123</code> You cannot use commas to separate groups of digits.</li>

<li><code>123.456.789,123</code> You cannot use the European convention for separating groups of digits and showing fractional parts.</li>

<li><code>123 456 789.123</code> You cannot use blanks to separate groups of digits.</li>

</ul>

You can, however, make numbers display in these formats by using the APL2 format functions, discussed in <a href="chapter7.html">Chapter 7</a>.

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

<ol>

<li>Evaluate the following expressions:

</ol></li>

<li>Write an equivalent number without using <code>E</code> notation for the following <code>E</code>-notation numbers:

</ol></li>

<li>In 1987, a woman slept an average of seven hours per day. Write an expression to determine how many hours she slept last year.</li>

</ol>

<h3 id="section-1.2-arithmetic-on-arrays">Section 1.2 — Arithmetic on Arrays<a href="#section-1.2-arithmetic-on-arrays" class="section-link">§</a></h3>

The best way to learn how APL2 solves problems is to see its problem-solving capability in action. This book presents many features of APL2 as problems for you to solve. For example, here’s a problem that involves doing the same calculation over and over again on a set of numbers.

A music store sells recorded music in various formats: long-playing records at $6.95, cassette tapes at $7.95, and compact discs at $12.95. This week they have a special sale—10% discount on all items.

</blockquote>

How much do you have to pay for each kind of recording?

A 10% discount means you pay 90% of the price. You could compute the selling prices in three separate computations as follows:

<pre> .9×6.95

6.255

.9×7.95

7.155

.9×12.95

11.655</pre>

This piecemeal process works. But perhaps the most important feature of APL2 is that it can express computations on more than one piece of data at a time. You can do the preceding computations in one expression that produces all three answers at once:

<pre> .9×6.95 7.95 12.95

6.255 7.155 11.655</pre>

Notice that the single number <code>.9</code> is multiplied by each of the numbers in the right argument.

<h4 id="thinking-arrays">Thinking Arrays<a href="#thinking-arrays" class="section-link">§</a></h4>

Applying a function like multiplication to whole arrays of data at one time is fundamental to the style of APL2. To be productive with APL2, you must learn to think in terms of arrays.

As another example of applying a function to a whole array of data, let’s suppose that last week the store sold higher priced items at a higher discount: long-playing records at 90% (still), cassette tapes at 80% of retail, and compact discs at 70% of retail. How much would you have had to pay for one of each kind of recording if you bought them last week?

If you’re not thinking arrays, you would do the calculations one at a time. Instead, think arrays and use the power of APL2 to compute the costs all at once:

<pre> .9 .8 .7 × 6.95 7.95 12.95

6.255 6.36 9.065</pre>

You enter a list of three numbers on each side of the multiplication, and again this gives three answers. You can view this computation as taking place like this:

<pre> (.9×6.95) (.8×7.95) (.7×12.95)

6.255 6.36 9.065</pre>

In fact, you can even enter the computation this way if you wish.

Continuing the music store example, suppose that, in addition to records at 10% off, the store also offers record cleaners (normally $2.50) at the same discount; and, in addition to pre-recorded cassette tapes at 20% off, it offers blank tapes (normally $3.55) and players (normally $295) at the same discount. Nothing other ’than the compact discs is offered at 30% off. You compute all the discounted prices at once as follows:

</center>

Do you see how APL2 calculates this? There are three discounts on one side of the multiplication and three groups of prices on the other side and you get three groups of numbers as the answer. You can view this computation as taking place like this:

<pre> (.9×6.95 2.5) (.8×7.95 3.55 295) (.7×12.95)

6.255 2.25 6.36 2.84 236 9.065</pre>

Notice that APL2 does not use parentheses when displaying the answer. It does use spaces to suggest the grouping of the data. Two blanks separate the three groups of answers, whereas one blank separates the numbers within a particular group.

<h4 id="adding-up-numbers">Adding up Numbers<a href="#adding-up-numbers" class="section-link">§</a></h4>

Suppose that this week you decided to buy one record, three cassette tapes, and two compact discs.

You know the price you have to pay for one of each item—it’s 90% of the list price:

<pre> .9×6.95 7.95 12.95

6.255 7.155 11.655</pre>

But you don’t want just one of each item. How would you compute what you have to pay for the items you buy? Just multiply each price by the number you want to buy:

<pre> 1 3 2 × .9 × 6.95 7.95 12.95

6.255 21.465 23.31</pre>

If you want to know only the bottom line— “How much money do I have to pay?”— you have to add up the three computed costs:

<pre> 6.255+21.465+23.31

51.03</pre>

Instead of entering the numbers that the machine just gave you, you can use reduction (<code>/</code>) together with addition (<code>+</code>) to request the sum as follows:

<pre> +/1 3 2 × .9 × 6.95 7.95 12.95

51.03</pre>

The summation (<code>+/</code>) applies after the two multiplications.

Reduction (<code>/</code>) is an APL2 operator. Reduction takes a function like addition and applies it between the items of the right argument. For example, these two expressions produce the same result:

<pre> +/10 15 20 <---summation

10+15+20 <---addition

45</pre>

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

<ol>

<li>Evaluate the following expressions:

</ol></li>

<li>Evaluate the following expressions:

</ol></li>

<li>In 1987, one woman slept an average of 7 hours a day, another averaged 7.5 hours a day, and a third 8 hours a day. Write one expression to compute the total number of hours each woman slept in 1987.</li>

<li>Suppose one object is traveling at velocity <code>X</code> and another is traveling at velocity <code>Y</code>.

<li>Write an expression that computes the relative velocity of the objects (that is, how fast one is moving away from the other) if they are traveling in opposite directions.</li>

<li>Suppose <code>X</code> is larger than <code>Y</code>. Write an expression that computes the relative velocity of the objects if they are traveling in the same direction.</li>

</ol></li>

<li>Suppose you have a 10-volume set of the publication “APL2 World” on a shelf. Each volume is 4 centimeters thick, including .25 centimeters for each of the front and back covers.

<li>Write an expression to compute how much linear space the 10 volumes occupy on the shelf.</li>

<li>Between the front cover and page 1 of volume 1, there is a bookworm. It eats its way through the books until it reaches the last page of the last volume. How long is the hole it leaves in your collection? (Note: trick question.)</li>

</ol></li>

</ol>

<h3 id="section-1.3-remembering-data">Section 1.3 — Remembering Data<a href="#section-1.3-remembering-data" class="section-link">§</a></h3>

The music store keeps changing its discounts from week to week. You can save some time by remembering the original prices (which apparently nobody pays). Then you need enter only the discounts to determine the costs of the various items. This section explains how APL2 uses names to remember data.

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

Any collection of data can be remembered by giving it a name. For example, the prices may be named <code>PRICE</code>:

<pre> PRICE←(6.95 2.5) (7.95 3.55 295) 12.95</pre>

A name that has been assigned values is a variable.

The association of a name with a set of values is an assignment of the name, and the left arrow is an assignment arrow. Notice that when you enter the expression, APL2 displays no numbers. When you enter the name of the variable, APL2 displays the numbers assigned to the name:

<pre> PRICE

6.95 2.5 7.95 3.55 295 12.95</pre>

Once you have assigned the name <code>PRICE</code>, you can compute last week’s consumer prices as follows:

<pre> .9 .8 .7 × PRICE

6.255 2.25 6.36 2.84 236 9.065</pre>

and this week’s prices can also be computed:

<pre> .9×PRICE

6.255 2.25 7.155 3.195 265.5 11.655</pre>

These computations do not affect the value of the variable <code>PRICE</code>. Only an assignment can give a value to a variable or change it.

Any place where you use a set of values, you can instead use a name assigned those values. Using the name instead of the values reduces the chance that a typing error will introduce incorrect data.

You can associate different sets of data with different names and use them independently or in combinations. Here is an example:

<pre> DISCOUNT←.9 .8 .7

DISCOUNT × PRICE

6.255 2.25 6.36 2.84 236 9.065</pre>

A name like <code>DISCOUNT</code> or <code>PRICE</code> is called a variable not because its value is continually changing but because, at different times, it can have different constant values. At any time, you can give a new value to a variable:

<pre> DISCOUNT←.7 .5 .7

DISCOUNT × PRICE

4.865 1.75 3.975 1.775 147.5 9.065</pre>

<h4 id="names">Names<a href="#names" class="section-link">§</a></h4>

As you saw in the previous section, you can assign values to a name and use the name in a computation. This section contains the rules for forming names.

In ordinary usage, people’s names are constructed as a list of characters chosen from the alphabet of their language. For example, “Caesar” is a name constructed from an alphabet consisting of uppercase and lowercase roman characters.

APL2 has rules that specify how to form valid names. In particular, no name may contain an imbedded blank. Blanks separate names. Thus, in APL2, the Roman leader’s more complete name is viewed as two names separated by a blank:

<pre> Julius Caesar</pre>

Construction of names in APL2 follows these rules:

<ol>

<li>The first or only character is from this set:</li>

</ol>

<pre> ABCDEFGHIJKLMNOPQRSTUVWXYZ

abcdefghijklmnopqrstuvwxyz

∆⍙</pre>

<li>The remaining characters, if any, are from the above set together with these:</li>

</ol>

<li>APL2 distinguishes between uppercase and lowercase letters. The following are different names. Case is not ignored:</li>

</ol>

<pre> Caesar

CAESAR

caesar</pre>

With some versions of APL2, underscored uppercase letters substitute for the lowercase alphabet. In this book, except for this section, neither the lowercase nor the underscored alphabetics are used for names.

Here are some examples of valid names:

<pre> A

ABC

Julius

L1011

This¯is¯a¯long¯name</pre>

Here are examples containing more than one name:

<pre> A+B <---Two names separated by a function symbol

GENGHIS KHAN <---Two names separated by a blank</pre>

Here is an example of an illegal name:

Names may be associated with different objects at different times or associated with no object at all.

To see the names that have values, enter the following command:

<pre> )NMS

PRICE.2 DISCOUNT.2</pre>

The <code>.2</code> following each name indicates that the name represents a variable. Later, you’ll see that the names of programs have the suffix <code>.3</code> or <code>.4</code>.

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

<ol>

<li>Which of the following combinations of characters represent a single valid APL2 name? (For any combination that is not a single valid name, state why it is not.)

</ol>

<ol>

</ol>

<li><code>DEPT,NUMBER</code></li>

</ol></li>

<li>In the following expressions, does the variable (or variables) change? If a variable changes, what is its new value?

</ol></li>

</ol>

<h3 id="section-1.4-evaluation-of-expressions">Section 1.4 — Evaluation of Expressions<a href="#section-1.4-evaluation-of-expressions" class="section-link">§</a></h3>

To understand the intent of an expression, you must know how APL2 evaluates that expression.

The following expression gives the same result no matter which multiplication is applied first.

<pre> 3×10×4

120</pre>

<code>3×10</code> multiplied by <code>4</code> is the same as <code>3</code> multiplied by <code>10×4</code>.

But the value of the following expression depends on whether you apply addition or multiplication first:

If <code>3</code> and <code>4</code> are added first, the result is <code>35</code>. If <code>4</code> and <code>5</code> are multiplied first, the result is <code>23</code>. The result in APL2 is <code>23</code>. This section explains how APL2 evaluates this and other expressions.

<h4 id="order-of-evaluation">Order of Evaluation<a href="#order-of-evaluation" class="section-link">§</a></h4>

The order of evaluation does not matter if the functions in an expression are all multiplication or addition because these functions are associative. Most often, the order of evaluation does matter and affects the way you construct the expression. Look at the expression needed to solve this problem:

You want to buy a shirt for $10.00 and a jacket for $20.00. There is a 5% sales tax on the purchase. How much do you have to pay?

</blockquote>

The clothing costs $10 plus $20 (which is $30). Including the tax, that’s 1.05 times $30. The following expression computes the cost of the shirt and jacket:

<pre> 1.05×10+20

31.5</pre>

Do you see how APL2 computes this? In expressions with numbers and functions like the preceding one, APL2 evaluates the rightmost function first no matter what the function is.

This evaluation may be pictured as follows:

</center>

This evaluation is different from normal arithmetic where you multiply before you add regardless of the order of the functions in an expression. APL2 has over 80 functions and remembering which function is executed before another would be nearly impossible. Therefore, APL2 follows an easy rule: Execute functions from right to left. Thus, the right argument of <code>×</code> is the result of the entire computation to its right.

You will find the right-to-left rule useful and easy to apply because it does not depend on what functions you are using. To see how the right-to-left rule works, consider this variation of the previous example:

Suppose that the $20 item you bought was not taxable. How would you prevent the multiplication by 1.05?

</blockquote>

You can rearrange the computation as follows:

<pre> 20+1.05×10

30.5</pre>

This evaluation proceeds right to left as follows:

</center>

<h4 id="use-of-parentheses">Use of Parentheses<a href="#use-of-parentheses" class="section-link">§</a></h4>

APL2 uses a familiar way to control the order of execution: parentheses. You’ve already seen parentheses used to group data. You use parentheses to group a computation as follows:

<pre> (2×5) + (3×6)

28</pre>

The evaluation of this expression is illustrated here:

</center>

If you want to change the order of evaluation, use parentheses for grouping.

To make an expression clearer, you can use parentheses even when they are not necessary. Parentheses that can be removed from an expression without affecting evaluation are redundant parentheses. The rightmost pair of parentheses in the expression <code>(2×5)+(3×6)</code> is redundant since the right-to-left rule would have caused the rightmost multiplication to be done first in any case. The computation can be written more compactly by removing the redundant parentheses as follows:

<pre> (2×5)+3×6

28</pre>

Redundant parentheses have no effect on the order of execution or the result of the computation. If parentheses help you understand what you write, use them.

<h4 id="use-of-blanks">Use of Blanks<a href="#use-of-blanks" class="section-link">§</a></h4>

You have already seen blanks used to separate one number from another number. Blanks are not needed to separate a number from a symbol but may be used if you wish. Thus, the following expressions produce identical values:

<pre> 2−3

¯1

2 − 3

¯1</pre>

Whenever you use one blank to separate one name, constant, or symbol from another, you can use multiple blanks as well. Thus, the following expressions produce identical values:

<pre> 2 3

2 3

2 3</pre>

While you can use extra blanks on entry, APL2 discards them.

<h4 id="vector-notation">Vector Notation<a href="#vector-notation" class="section-link">§</a></h4>

A list of data is called a vector. You’ve already seen several examples of vectors.

You denote vectors of length two or longer by writing the values of the items next to each other. This is called vector notation. Here is a two-item vector:

<pre> 3 5

3 5</pre>

To form this vector, you write the constant <code>3</code> next to the constant <code>5</code> separating them by a blank to avoid confusion with the number <code>35</code>.

You can also compute <code>5</code> by placing in parentheses an expression that yields <code>5</code>, such as:

<pre> 3 (1+4)

3 5</pre>

These parentheses are not redundant. Removing them changes the meaning of the expression:

<pre> 3 1+4

7 5</pre>

At first glance, this expression might look as if it contains two things: <code>3</code> and <code>1+4</code>. But APL2 is an array processing language and operates on whole collections of data in one gulp. Therefore, it is more important to form collections of data (like <code>3 1</code>) than it is to apply functions. Thus, APL2 groups <code>3</code> and <code>1</code> before addition is evaluated. So APL2 evaluates this expression (using redundant parentheses) like this:

<pre> (3 1)+4

7 5</pre>

The two-item vector resulting from <code>3 (1+4)</code> has the same value as <code>3 5</code> and may be used in an expression anywhere <code>3 5</code> is used.

<pre> 3 5 × 10

30 50

3 (1+4) × 10

30 50</pre>

You can also produce the same vector by using a name that has been assigned the value 5:

<pre> AS←5

3 AS

3 5

3 (AS+2)

3 7</pre>

An assignment may be imbedded in an expression:

<pre> 3 AS←5

3 5</pre>

The assignment <code>AS<5</code> produces its right argument <code>5</code> as its value.

When the assignment is leftmost in an expression, the resulting value does not print.

When the assignment is not leftmost in an expression, the value may be used for further computation:

<pre> 2+AS←5

7</pre>

The assignment only applies to the name immediately on its left:

<pre> AT←3

AT AS←5

3 5</pre>

More than one name may be assigned in one operation by using parentheses:

<pre> (AT AS)←3 5

5</pre>

One value may be assigned to several names:

<pre> (AT AU)←10

10</pre>

Again, the result of the assignment is the value to the right of the left arrow, and it does not print if the assignment is leftmost in the expression.

If the assignment is not leftmost in the expression, its value may be used for further computation as though the assignment were not present:

<pre> 3+(AT AU)←10

13</pre>

You can write vectors containing vectors, surrounding each vector item by parentheses:

<pre> (1 2 3) (4 5)

1 2 3 4 5</pre>

This is a two-item vector each of whose items is also a vector. The parentheses group the items. Notice how the spacing of the displayed result gives you a hint that this result is something other than a five-item vector. Although APL2 uses spacing on output to suggest grouping, you cannot use spaces to indicate grouping on input. You must use parentheses.

Items of a vector of vectors may be assigned to different names:

<pre> (AA BB)←(1 2 3) (4 5)

1 2 3

10+BB

14 15</pre>

These are the important points about vector notation:

<ul>

<li>You can write only a vector of length two or longer using vector notation.</li>

<li>You represent each item in vector notation as a constant, a name, or an expression in parentheses.</li>

<li>You use parentheses only for grouping. They do not indicate multiplication or have any other significance.</li>

<li>Vectors are more important than functions. If, when looking at an expression, you have a choice between forming a vector or applying a function, form the vector.</li>

</ul>

<h4 id="display-function"><code>DISPLAY</code> Function<a href="#display-function" class="section-link">§</a></h4>

APL2 uses spaces to suggest the structure of a vector. If you are studying a result and want to know its structure for sure, you use the <code>DISPLAY</code> function.

The <code>DISPLAY</code> function is available with many APL2 systems. <a href="appendixA.html">Appendix A</a> shows the definition of the function and tells you how to locate it on your APL2 system.

To use <code>DISPLAY</code>, simply enter its name and, as its right argument, the expression whose value you want to examine:

<pre> DISPLAY 2 4 6

.→----.

|2 4 6|

'∼----'</pre>

<code>DISPLAY</code> shows a numeric vector within a box with a right pointing arrow on the top edge, indicating data organized along one direction (a vector). The <code>∼</code> on the bottom edge indicates numeric data.

If some of the items of a vector are vectors themselves, <code>DISPLAY</code> boxes these items as well:

<pre> DISPLAY (3 4 6) 5 (9 7)

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

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

| |3 4 6| 5 |9 7| |

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

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

The symbol <code>∊</code> appears on the bottom edge of any box that contains an item that is not a single number or character.

<a href="chapter5.html">Chapter 5</a> tells you more about the <code>DISPLAY</code> function.

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

<ol>

<li>In the following expressions, indicate the order of execution of the functions by writing a number on the line below each function (1 under the first function evaluated, and so on):

<li><pre>54 − 17 × 10 — 12 + 3

___ ___ ___ ___</pre></li>

<li><pre>(54 − 17 × 10) — 12 + 3

___ ___ ___ ___</pre></li>

<li><pre>(54 − 17) × 10 — 12 + 3

___ ___ ___ ___</pre></li>

<li><pre>(54 − 17) × (10 — 12) + 3

___ ___ ___ ___</pre></li>

</ol></li>

<li>Evaluate the following expressions. Indicate which, if any, parentheses are redundant:

</ol></li>

<li>Evaluate the following expressions:

</ol>

<ol>

</ol>

</ol></li>

<li>Evaluate the following expressions. Write your answers with parentheses to show grouping:

</ol></li>

<li>State the value of the following expressions and indicate whether the value prints. Assume that assignments remain in effect through the end of the exercise:

</ol></li>

<li>Given five variables:

<pre> A←2 3

B←4

C←(1 5)(6 7)

D←A B C

E←A B</pre>

Evaluate the following expressions:

</ol></li>

<li>A polyhedron is a solid three-dimensional figure bounded by flat surfaces. Where two flat surfaces meet, a straight line is formed. Where three or more lines meet, a point called a vertex is formed. Write an expression that computes the sum of the vertices and surfaces, and then subtracts the number of edges, for the following figures:

<li>Tetrahedron (pyramid) with 4 vertices, 6 edges, and 4 surfaces.</li>

<li>Octahedron with 6 vertices, 12 edges, and 8 surfaces.</li>

<li>Icosahedron with 12 vertices, 30 edges, and 20 surfaces.</li>

</ol></li>

<li>A light-year is the distance that light travels in a year.

<li>Write an expression to determine the number of miles light can travel in one, two, and three years if light travels 186,281 miles in one second.</li>

<li>Write an expression to determine the number of kilometers light can travel in one, two, and three years if one mile is 1.6 kilometers.</li>

</ol></li>

<li>Given that temperature in Fahrenheit is 32 plus nine-fifths of a degree in Celsius, write expressions to reflect the following computations:

<li>Convert Fahrenheit temperature <code>FEH</code> to Celsius.</li>

<li>Convert Celsius temperature <code>CEL</code> to Fahrenheit.</li>

</ol></li>

<li>In 1984, three women slept 7, 7.5, and 8.2 hours per day, respectively. Write an expression to determine the percentage of the year each woman slept.</li>

<li>Suppose you kept a weekly record of the length of time in minutes you slept each day. Here’s an example:

Write an expression to determine the percentage of the week spent sleeping.</li>

<li>Write an expression to find the total cost <code>TCOST</code> of some items, given the following variables:

<ul>

<li><code>PRICES</code> — a vector of the individual item prices.</li>

<li><code>QTY</code> — the quantity of each item purchased.</li>

<li><code>STAX</code> — the sales tax as a percentage.</li>

</ul></li>

<li>At a recent family visit to the dentist, your dentist provided the following services:

<ul>

<li>Examined and X-raved your two children’s teeth.</li>

<li>Filled two teeth for your spouse.</li>

<li>X-rayed and checked your teeth and filled one tooth.</li>

</ul>

An examination and X-ray cost $45 and each filling costs $15. Write an expression to determine your charges, assuming that your dental insurance pays 80% of the dental expense above $25 for each individual.</li>

<li>Write an expression to interchange the values of the two variables <code>A</code> and <code>B</code>.</li>

</ol>

<h3 id="section-1.5-saving-your-work">Section 1.5 — Saving Your Work<a href="#section-1.5-saving-your-work" class="section-link">§</a></h3>

When you begin an APL2 session, no name has a value. As you work, you may assign values to some names. You do not want to lose them when you have finished using APL2. <a href="chapter4.html">Chapter 4</a> shows you the best way to save work when you have finished and get it restored when you want to use APL2 later. For now, it is sufficient to know that entering the following command stops APL2 and saves your work:

<pre> )CONTINUE

1988-05-01 18.22.43 CONTINUE </pre>

This command saves your work and terminates the APL2 session. You may also see some termination messages depending on the particular APL2 implementation you are using. Next time you start up APL2, you should see the following message:

<pre>SAVED 1988-05-01 18.22.43</pre>

All the names you defined In your previous session are again available to you.

Using <code>)CONTINUE</code> is not the recommended way to save your work once you become familiar with the APL2 library system, but it will do the job until you reach <a href="chapter4.html">Chapter 4</a>.

<h3 id="section-1.6-errors">Section 1.6 — Errors<a href="#section-1.6-errors" class="section-link">§</a></h3>

Trying out the examples in this chapter may have led to any number of mistakes, Perhaps you spelled a name wrong, wrote an incorrect number, tried to add two numbers to three numbers, used a name before assigning it a value, and so forth.

Here’s an example in which enter was pressed before the right argument was given for a function:

<pre> 2+

SYNTAX ERROR

^^</pre>

After each error, entering a <code>→</code> clears out APL2’s memory of the error:

<h4 id="types-of-errors">Types of Errors<a href="#types-of-errors" class="section-link">§</a></h4>

The following are some errors you may make. Each one contains a brief description of the type of error. Note that after each error occurs, the example shows a <code>→</code> being used to clear the error from APL2’s memory:

<ul>

<li>Entering a name that has no value:

<pre> PRICF

VALUE ERROR

PRICF

→</pre></li>

<li>Entering a function with no right argument:

<pre> 2+

SYNTAX ERROR

→</pre></li>

<li>Trying to add vectors of different lengths:

<pre> 1 2 3 + 4 5

LENGTH ERROR

1 2 3+4 5

^ ^

→</pre></li>

<li>Using an argument not in the domain of a function:

<pre> (X<5)÷0

DOMAIN ERROR

(X←5)÷0

^ ^

→</pre></li>

</ul>

The error messages may seem rather terse at first, but you will quickly learn to spot the error they indicate. Whenever APL2 displays two carets (<code>^</code>) in an error report, the rightmost one points to the function in which APL2 detected the error. The left caret shows how far to the left APL2 has looked at the expression in its application of the right-to-left rule. Thus, in the illustration of <code>DOMAIN ERROR</code>, the rightmost caret shows that the error occurred in division. The leftmost caret shows that the assignment to X has already been done.

When APL2 displays one caret in an error report, it is both leftmost and rightmost.

<h4 id="clearing-errors">Clearing Errors<a href="#clearing-errors" class="section-link">§</a></h4>

Suppose you make these errors and don’t clear them with <code>→</code>:

<pre> 1 2 3 + 4 5

LENGTH ERROR

1 2 3+4 5

^ ^

2÷0

DOMAIN ERROR

2÷0

^^</pre>

You can determine the errors that you have not cleared by entering the following system command:

<pre> )SIS

⋆ 2÷0

⋆ 1 2 3+4 5

^ ^</pre>

This list of uncleared errors is a display of the state indicator. The state indicator keeps track of expressions and programs that have started execution but have not completed. <code>SIS</code> stands for State Indicator with Statements.

In <a href="chapter7.html">Chapter 7</a>, you’ll find that you can make use of the information in the state indicator. For now, you should just clear it. To clear the state indicator of uncompleted expressions, enter a right arrow for each <code>⋆</code> that you see in the <code>SIS</code> display.

<pre> →

→</pre>

Then reenter <code>)SIS</code> to verify that you have cleared the state indicator completely:

As an alternative to using <code>→</code> repeatedly to clear the errors, you can enter the following command to clear them all:

<pre> )RESET</pre>

Although <code>)RESET</code> is convenient, particularly if you neglected to clear many errors, it is best to clear out each error immediately after you make it.

If you ever want to clear out less than everything in the state indicator, you can use <code>)RESET</code> with a number to remove that many expressions from the top of the state indicator:

<pre> )RESET 3</pre>

This command removes the top three expressions from the <code>)SIS</code> display.

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

<ol>

<li>What error message (if any) would APL2 produce if the following expressions were entered in order? For each that results in an error message, explain what is wrong. Possible answers are:

<ul>

<li>no error — expression will execute</li>

<li><code>SYNTAX ERROR</code> — expression doesn’t make sense</li>

<li><code>VALUE ERROR</code> — name has no value</li>

<li><code>LENGTH ERROR</code> — lengths don’t match</li>

<li><code>DOMAIN ERROR</code> — cannot compute a function</li>

</ul>

<li><pre>A←10

B←20

C←AB</pre></li>

</ol></li>

<li>Suppose the state indicator looks like this:

<pre> )SIS

⋆ 2+

⋆ 10+0

^ ^

⋆ 2 3+4 5 6

^ ^

⋆ PRICF

^</pre>

What will the state indicator look like after each of the following (assume the same state indicator contents before each question):

<li><pre>→

→</pre></li>

<li><code>)RESET 4</code></li>

<li><code>)RESET</code></li>

</ol></li>

</ol>

<h3 id="section-1.7-terminology">Section 1.7 — Terminology<a href="#section-1.7-terminology" class="section-link">§</a></h3>

This chapter has introduced many new ideas—some named, some shown only in examples. You learn faster if the key ideas all have names. You probably already know the concepts; you’ve seen examples of them in use. In this section, the concepts get names.

The terms for describing data are the most important. Be sure you understand them. Terms used for describing functions and operators are important especially if you plan to read other APL or APL2 books or manuals.

<h4 id="terms-for-data">Terms for Data<a href="#terms-for-data" class="section-link">§</a></h4>

In APL2, any collection of data is an array. An array can be a single number or a single character or it can be a collection of thousands of numbers and characters. A single number or a single character is a simple scalar. Here are some simple scalars:

<pre> 5

37</pre>

Note that 37 is a single number, and so it is a simple scalar, even though it contains more than one digit.

A list of data arranged in a line is a vector and the pieces of data in any arrangement are items.

If every item of a vector is a simple scalar, the vector is a simple vector. Here are some simple vectors:

<pre> 2 3 4

2 3 4

2 (2+1) 4

2 3 4</pre>

If any item of a vector is not a simple scalar, the vector is a nested vector. Here is a nested vector:

<pre> (6.95 2.5) (7.95 3.55 2.95) 12.95

6.95 2.5 7.95 3.55 2.95 12.95</pre>

The first two items of this vector are simple vectors, and the third item is a simple scalar.

<h4 id="terms-for-operations">Terms for Operations<a href="#terms-for-operations" class="section-link">§</a></h4>

An operation takes inputs and produces an output. An operation can be a function or an operator.

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

A function is an operation that, when given data, produces new data. You’ve seen several functions in this chapter, and you’ll see many more before you’ve finished with this book.

Functions supplied with your APL2 system are called primitive functions. Primitive functions are normally denoted by symbols. <a href="appendixE.html">Appendix E</a> lists the symbols and their names. They are always available for your use. Later when you begin to program in APL2, you will write defined functions which behave like the primitive functions except you provide their definition and you denote them by giving each a name.

The arrays to which a function applies are the arguments of the function (this word does not imply any difference of opinion). The array produced by the function is called the explicit result (or, loosely, the result).

Here is how these terms apply to the function subtraction:

<pre> 17−5

12</pre>

Subtraction (<code>−</code>) is a primitive function. <code>17</code> and <code>5</code> are its arguments. The difference (<code>12</code>) is the explicit result. This explicit result can be used as an argument to another function:

<pre> 1+17−5

13</pre>

Subtraction requires two arguments, one on the left and one on the right. A function that applies between two arrays is a dyadic function.

On the other hand, negation (<code>−</code>) is a function that applies to one array (its argument) and produces an array (its explicit result):

<pre> − 2 3 ¯5

¯2 ¯3 5</pre>

A function that applies to one argument, written on the right, is a monadic function.

A dyadic function is one with both left and right arguments and a monadic function is one with only a right argument.

You have seen the mid-minus symbol (<code>−</code>) used as both the dyadic subtraction function and the monadic negate function. In general, any APL2 function symbol represents two functions—one monadic and one dyadic.

For a function in a given expression, if a left argument is present, the dyadic function is always the one applied.

<h5 id="operators">Operators<a href="#operators" class="section-link">§</a></h5>

An operator is an operation that produces a new function. You’ve only seen one operator so far: reduction. Operators supplied with the APL2 system are primitive operators and are denoted by symbols. Operators you write are defined operators. The functions or arrays to which an operator applies are the operands of the operator and the function which results is the derived function.

Operators may be monadic or dyadic according to whether they are defined to take one or two operands. The operand of a monadic operator is written to the left of the operation. An APL2 operator symbol always represents a single operator and is monadic or dyadic by definition, not by context.

Here is how these terms apply to the operator reduction:

<pre> +/ 10 20 30

60</pre>

Reduction (<code>/</code>) is a monadic primitive operator that produces a monadic function. Its operand is the function addition (<code>+</code>). Applied to addition, reduction produces the derived function summation (<code>+/</code>). This derived function is then applied to its argument as with any other monadic function.

<h4 id="commands">Commands<a href="#commands" class="section-link">§</a></h4>

A line that begins with a right parenthesis is called a system command. So far you’ve seen four system commands: <code>)NMS</code>, <code>)CONTINUE</code>, <code>)SIS</code>, and <code>)RESET</code>. A system command is not an APL2 expression or an operation. You cannot execute a system command from within a program. It is a means of requesting some information or some action from the APL2 system. <code>)NMS</code> asks for a display of the names currently defined. <code>)CONTINUE</code> requests an end to the current APL2 session with retention of the definitions of any names for the next session.

View this page on the web

View page source