\documentclass{article} \usepackage[utf8]{inputenc} \input apl.tex \begin{document} \begin{verbatim} Scalar Functions Summary 1. Introduction 2. Constants 2a. Numeric Constants 2b. Character Constants 2c. Symbol Constants 2d. Nested Constants 3. Scalar Functions 4. Arithmetic Scalar Functions 5. Operators 5a. Reduction 5b. Outer Product 5c. Scan 5d. Inner Product 6. Selection and Assignment 7. Relational Scalar Functions 8. Logical Scalar Functions 8a. Reduction Revisited 8b. Scan Revisited 9. Elementary Algebraic and Transcendental Scalar Functions 10. Miscellaneous Scalar Functions 10a. Absolute Value and Residue 10b. Signum 10c. Floor and Minimun 10d. Ceiling and Maximum 10e. Roll 11. Tables Table 1. Scalar Functions Table 2. Operators on Scalar Functions 1. Introduction This tutorial is for the reader who has little or no experience with programming in APL-like programming languages. The scalar functions exhibit many of the qualities that make A+ an effective programming language, while at the same time being generally familiar, so this is a good place to start. As you will learn, many program fragments in A+ can be stated in a few expressions that do not include explicit control statements. This expressiveness sometimes depends on using A+ primitive functions in ways that are not apparent from their definitions. So, don't expect to see all or even most uses of the A+ primitive functions in these tutorials. The tutorials are meant to introduce you to the language and some of its uses, but when you're done many surprises will still lie ahead. Who would want it otherwise? This tutorial is made up of textual descriptions and A+ examples. To execute the examples conveniently you should set up your Emacs environment to have two visible buffers, one holding the tutorial and the other an A+ session. If you are currently reading this in Emacs, simply press F4. The examples consist of indented A+ expressions and their values. Sometimes the text refers to the values, and it is helpful to have them handy, but the main reason they are displayed is to help you become familiar with A+ in the Emacs environment. In the later tutorials the values usually do not appear in the text. You should evaluate the indented expressions, and compare the results in the A+ session with those in the text. For example, when you see a display of the form 1 2+3 4 4 6 the indented expression 1 2+3 4 is the one to bring into the A+ session for evaluation. The second expression, 4 6, is the result of executing the indented expression and should not be brought into the A+ session for evaluation. To bring individual expressions from the tutorial into the A+ session, place the cursor on the expression and press F2. When an expression is brought into A+ in this way, it is automatically evaluated, and its value is displayed. The displayed value should be identical to the display in the tutorial. If you need more help on running Emacs and A+, see the "Getting Started" tutorial. If you want to try your hand at devising your own A+ expressions, see the keyboard layout diagrams in Chapter 2 and Appendix B of the A+ Reference Manual. 2. Constants 2a. Numeric Constants There are several preliminary things to discuss. First of all, a list of numeric constants can be entered on a line by separating the individual numbers with blanks, as in 3 4.5 7 3 4.5 7 This is a list of the three numbers, 3, 4.5 and 7. Secondly, negative numbers are denoted by a raised minus sign. For example: 5+¯2 3 Exponential notation can be used for fractional, or floating-point, numbers, as in 1.23e5 123000 which is 1.23 times 10 to the 5, or 123000. Negative exponents are denoted with the usual minus sign, not the raised minus sign, so that ¯2000e-2 ¯20 is negative 2000 times 10 to the negative 2, or negative 20. 2b. Character Constants A single character is entered surrounded by quotation marks, and a list of characters is entered in exactly the same way. For example: 'axcdert' axcdert Either single quotes or double quotes can be used, but they must both be the same. For example: "axcdert" axcdert It is interesting to see how a quotation mark can be included in a list of characters. If a single quotation mark is to be included, surround the list with double quotes; if a double quote mark is to be included, surround the list single quotes. For example: 'He said, "Oh no!"' He said, "Oh no!" "I can't go." I can't go. The question then becomes, how are both quotation marks included in the list? The answer is that the one that is identical to the quotes surrounding the list must be doubled. For example: '"I can''t go either," he said.' "I can't go either," he said. 2c. Symbol Constants A symbol constant is of the form backquote,characters. An example is ThisIsASymbol. It provides a form that enables rapid comparison and is convenient for aggregation. A vector of symbols can be written simply by juxtaposing them, with or without blanks between them: s1 s2s3 s4 s5s6 s1 s2 s3 s4 s5 `s6 2d. Nested Constants In addition to numeric, character, and symbolic data, A+ has nested, or boxed, data. Nested data comes in lists, like numeric, character, and symbolic data, except that the elements are not restricted to individual numbers, characters, or symbols; they can be anything. For example: (2 3.5 ¯7;'dfgtyuh') < 2 3.5 ¯7 < dfgtyuh This constant has two elements. The < in the display indicates that what follows is a boxed element. An easy way of producing nested arrays is to use strand notation, as in the example. It is of the form (...;...;...) and its value is a list, or vector. The successive elements of this list are the enclosures, or boxed forms, of the successive expressions between semicolons or between a semicolon and a left or right parenthesis. 3. Scalar Functions For convenience, the scalar functions have been divided into categories that may be familiar to you. The arithmetic functions are Plus, Minus, Times and Divide. The relational functions are Equal to, Not equal to, Less than, Less than or Equal to, Greater than, and Greater Than or Equal to. The logical functions are And, Or, and Not. The elementary functions are Power, Log, and certain trigonometric and algebraic functions. Finally, there is a miscellaneous set. The names and symbols of the scalar functions are summarized in Table 1, at the end of the tutorial. The expressive power of the scalar functions in A+ is largely due to useful variations provided by operators. "5. Operators" introduces Reduction, Scan, Outer Product and Inner Product. Table 2, at the end of the tutorial, tells which of these operators apply to which scalar functions. 4. Arithmetic Scalar Functions The common arithmetic operations are examples of scalar functions in A+. They are Plus (+), Minus (-), Times (×), and Divide (÷). They apply to individual numbers, as in: 3+4 7 and they apply to lists in an element-by-element fashion. For example: 2 5 ¯7 + 10 12 15 3 In this example the three numbers, 2, 5, and ¯7, are added to 10. The result is a list of three numbers. The spaces around the symbol + are meant as an aid to readability and are not necessary. A list of numbers can appear on the right of the operation symbol as well as the left, as in the following subtraction example: 200 - 27 ¯34.56 1.521e2 129 173 234.56 47.9 71 and there can be lists on both sides of the symbol: 2 7 9 × 10 ¯3 4 20 ¯21 36 When there are two lists, i.e., more than one element on each side, the number of elements must be the same on each side. The operation of negation is denoted by - in mathematics, and in A+ as well. For example: - 3 6.7 ¯12 102 1e-3 ¯3.4e3 ¯3 ¯6.7 12 ¯102 ¯0.001 3400 The use of one symbol to denote two operations, such as the - symbol for subtraction and negation, is carried over in A+ to almost all its primitive operations. For example, ÷ denotes both division and the taking of reciprocals, as in: 2 ¯3 10 ÷ 5 6 5 0.4 ¯0.5 2 and ÷ 5 10 12 0.2 0.1 0.08333333333 The number or list of numbers that appears to the left of a symbol is called the left argument of the operation. That which appears to the right is called the right argument. The two together are referred to as the arguments of the operation. When there are two arguments, the operation is said to be dyadic. When an operation has only argument, when nothing appears to the left of its symbol that could serve as the left argument, it is said to be monadic. Symbols, such as -, that have both a monadic and dyadic use are called ambivalent. Most primitive function symbols in A+ are ambivalent. It is time to adopt some conventional A+ terminology. The common mathematical term for +, -, × and ÷ is operation. Operations are examples of the general mathematical notion of function, but the term operation is quite commonly used in mathematics when the symbol for the dyadic function appears between the arguments. However, in A+ we tend to use the more general term "function", even for the arithmetic operations. This may be due to the fact that A+ also has operators, another common mathematical concept, and the use of two closely related terms can be confusing. Whatever the reason, we will adopt the A+ convention, and from now on we will refer to the arithmetic operations as functions, and in particular as scalar functions. Ex 1. A mistake that is often made concerning numeric constant lists such as 1 5 ¯12 21 is to attach functional significance to the spaces between items. Now that we have seen how scalar functions are evaluated, we can examine this common pitfall. For example, one might expect to be able to form the list consisting of 5 plus 23, 24 minus 13, and 10 times 6 simply by putting these expressions on a line separated by blanks, as in: 5+23 24-13 10×6 To understand how this expression is evaluated you need to know the following (see the Syntax tutorial for a general discussion): the first thing done in evaluating this expression is to form the constant 13 10; the next thing done is to form the constant 23 24; next, the function × is evaluated; then -; and finally +. Use these rules and your knowledge of scalar functions to evaluate this expression by hand. Check your answer by bringing this expression into the A+ session for evaluation with F2. The next common expectation is to be able to put each of the expressions 5 plus 23, 24 minus 13, and 10 times 6 in parentheses, and then put these three parenthesized expressions on a single line separated by blanks, as in: (5+23) (24-13) (10×6) But this is an invalid expresson, and an attempt to evaluate it will result in an error message: PARSE +... : var? or, in Version 3, ⍝[parse] +... : var? To put the results of individual expressions like these three together in a list, you must use the function designed for that purpose, which is called Catenate and is denoted by the comma. Use F2 to evaluate the following expression: (5+23),(24-13),(10×6) Ex 2. Write two expressions for a 5-element list whose first two elements are those of the list 14+4 8 and whose last three elements are those of the list 4 9 12-3 10 7. 5. Operators In mathematics, operators are objects that act on functions to produce new functions. A+ has several operators that act on scalar functions. We will introduce them here for the arithmetic functions, and return to them later as more scalar functions are introduced. 5a. Reduction The slash (/) denotes an A+ operator called reduction. For example, +/ denotes + reduction, and ×/ denotes × reduction. The function symbol always appears to the left of the slash. The functions +/ and ×/ are called derived functions because they are derived from other functions, namely + and ×. A hint at how these derived functions are defined is that +/ is also called summation. +/3 5 8 12 28 3+5+8+12 28 +/1 2 3 4 5 6 7 8 9 10 55 1+2+3+4+5+6+7+8+9+10 55 That is, +/ takes the sum of all elements in a list. The reduction operator applies uniformly to all functions whose symbols are permitted to the left of the slash (see Table 2), so you should suspect that × reduction takes the product of all elements in a list. ×/3 5 8 12 1440 3×5×8×12 1440 ×/1 2 3 4 5 6 7 8 9 10 3628800 1×2×3×4×5×6×7×8×9×10 3628800 5b. Outer Product The symbols ∘. denote the operator called outer product. ∘.+ is called the outer product of + and ∘.× is called the outer product of ×. The outer product operator is sometimes called the table maker, and here is an example: 1 6 ¯2 3∘.+4 10 3 5 11 4 10 16 9 2 8 1 7 13 6 When you execute the above outer product expression you will see the four separate lines displayed below the expression. These four lines are the rows of a table. You will note that the numbers in these rows line up vertically. The aligned vertical lists are the columns of the table. This table contains all combinations of sums of elements from the list on the left with elements from the list on the right. For example, the number at the third row, second column of the table is 8. By definition, it is the sum of the third element of the list on the left, ¯2, and the second element of the list on the right, 10. Pictorially: + ∣ 4 10 3 ---∣--------- 1 ∣ 5 11 4 6 ∣ 10 16 9 ¯2 ∣ 2 8 1 3 ∣ 7 13 6 Like reduction, the outer product operator applies uniformly to all functions whose symbols are allowed to the right of the ∘. (see Table 2). For example, the tables produced by ∘.× contain all combinations of products, as in: 1 6 ¯2 3∘.×4 10 3 4 10 3 24 60 18 ¯8 ¯20 ¯6 12 30 9 5c. Scan The backslash (\) denotes the A+ operator called scan. Scan is a companion of reduction: for example, while + reduction gives the sum of a list of numbers, + scan gives the running, or partial, sums: +\1 3 ¯5 2 6 1 4 ¯1 1 7 +/1 1 +/1 3 4 +/1 3 ¯5 ¯1 +/1 3 ¯5 2 1 +/1 3 ¯5 2 6 7 Note that something new about reduction has come up. Namely, + reduction of a single number is that number. In fact, this is true for any reduction. This is a separate definition from the one for lists with at least two elements, because there aren't enough elements to put the function symbol between. 5d. Inner Product The fourth and last operator to be introduced here is inner product, denoted by the dot (.). Unlike the other operators, inner product applies to a pair of scalar functions. For example, the inner product of + and × is denoted by +.×. The function +.× is dyadic, and when applied to lists, as in a+.×b, is equivalent to +/a×b. For example: 34 ¯1 5 12+.×3 14 10 ¯5 78 and 34 ¯1 5 12×3 14 10 ¯5 102 ¯14 50 ¯60 +/ 102 ¯14 50 ¯60 78 Inner products also apply to tables, and when +.× is applied to tables it is equivalent to the ordinary matrix product in linear algebra. 6. Selection and Assignment Variables can be assigned values by placing their names to the left of the assignment arrow and the values to the right. For example: a←12 ¯23.921 83214 ⍝ No value is displayed for assignment. Enter the name alone on a line, press the Return key, and the value will be displayed: a 12 ¯23.921 83214 Once a variable has a value individual elements can be replaced. For example: a[1]←1024.7 ⍝ No value is displayed for indexed assignment. a 12 1024.7 83214 Individual elements can be selected as well: a[1] 1024.7 a[2 1] 83214 1024.7 ⍝ Elements can be selected in any order. Note that for the purposes of selection and assignment, the first element is element number 0, the second element is element number 1, and so on. These numbers are called the indices of the elements. For example, in the above list a: 12 is the element at index 0 1024.7 is the element at index 1, and 83214 is the element at index 2. Note that not only can elements be replaced, but the entire value can also be replaced: a←'x' ⍝ No value is displayed for assignment. a x 7. Relational Scalar Functions The mathematical relations (=, ≠, <, ≤, >, ≥) are ordinary scalar functions in A+. They apply to lists of numbers in the same way as the arithmetic functions. They return boolean results, i.e., the numbers 0 and 1, where 1 indicates that the relation holds, and 0 that it does not. For example: 3 10<7 ¯4 1 0 The value 1 0 expresses the fact that 3 is less than 7 but 10 is not less than ¯4. Equal to and Not equal to apply to lists of characters and nested lists as well as lists of numbers. For example: 'a'='xcade' 0 0 1 0 0 'a'≠'xcade' 1 1 0 1 1 (1 2 3;'abcdef')=(1 2 3;'fed') 1 0 The advantage of the relations' being functions is that they can then be used in ordinary, mathematical-like expressions. For example, to evaluate the sum of the positive numbers in a list named w: w←1 2 ¯4 12 0 ¯7 14 2 ¯3 +/(w>0)×w 31 Here is how it works. The subexpression w>0 produces a list of 1's and 0's; the 1's appear wherever the elements of w are positive. Then since 1 times any number is that number and 0 times any number is 0, an element of (w>0)×w is equal to the corresponding element of w when the latter is positive, and 0 when it is 0 or negative. Since 0's do not contribute to a sum, +/(w>0)×w is the sum of the positive elements of w. w>0 1 1 0 1 0 0 1 1 0 (w>0)×w 1 2 0 12 0 0 14 2 0 +/(w>0)×w 31 Note that the last expression is equivalent to the following inner product: (w>0)+.×w 31 The outer product operator also applies to relational functions as well as the arithmetic ones. For example, we can answer the following question: how many times does each character in a list occur in that list? The answer for: x←'ancahac' is 3 1 2 3 1 3 2. That is, reading the list of characters from left to right, there are three a's, one n, two c's, three a's again, one h, three a's again, and two c's again. (The matter of removing repetitions from the list of character counts is discussed in the "Simple Arrays" tutorial). We can use the outer product of = to compare every character of x to every other character. x∘.=x 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 1 0 0 0 1 0 0 0 1 The following display shows how the elements of x are related to the elements of the outer product result. = ∣ a n c a h a c -- -------------- a ∣ 1 0 0 1 0 1 0 n ∣ 0 1 0 0 0 0 0 c ∣ 0 0 1 0 0 0 1 a ∣ 1 0 0 1 0 1 0 h ∣ 0 0 0 0 1 0 0 a ∣ 1 0 0 1 0 1 0 c ∣ 0 0 1 0 0 0 1 If we look down any column of the outer product table, we see 1's whenever a character in the list x matches the character at the head of the column. If we sum the 1's in that column, we get the number characters in x that match the character at the head of the column. Of course the sum of the 1's in a column is simply the sum of the column because the other elements are 0. Therefore, + reduction of the columns gives us the answer: +/x∘.=x 3 1 2 3 1 3 2 You may have noticed that the table is symmetric. That is, we could just as well have summed the rows of the table to get the result. However, reduction applies to the columns by default. We will see how to apply reduction to the rows of a table in the "Simple Arrays" tutorial. 8. Logical Scalar Functions The logical functions are And and Or, and are denoted by ∧ and ∨. They apply to boolean values and produce boolean values. They are defined as follows: 0∧0 equals 0 0∨0 equals 0 0∧1 equals 1∧0 equals 0 0∨1 equals 1∨0 equals 1 1∧1 equals 1 1∨1 equals 1 We say that the result of ∧ is "true" (i.e., 1) if both its arguments are true; the result is "false" if at least one argument is false. Similarly, the result of ∨ is true if at least one argument is true; the result is false if both arguments are false. The logical functions are often used to form compound relational expressions. For example, the following expression tests whether or not one of the two numbers c and b is greater than 10 (first giving c and b values so that the test can be evaluated): c←5 b←11 (c>10)∨(b>10) 1 If you wanted to know whether or not both c and b are greater than 10, the test expression would be: (c>10)∧(b>10) 0 Note: the way to read A+ expressions is from left to right. For example, the above expressions is "c greater than 10 and b greater than 10." If either c or b (or both) are lists the situation is more complicated because the value of the expression will be a list of boolean values stating whether the individual elements of c and b satisfy the test. For example: c←5 21 ¯7 50 b←2 ¯10 20 17 (c>10)∨(b>10) 0 1 1 1 (c>10)∧(b>10) 0 0 0 1 Consequently, depending on the problem at hand, you will usually want to know if all the individual relations hold , or if at least one does. However, many other conditions can arise, such as knowing that at least two of the individual relations hold. Using only what we know now about A+, we can determine the number of individual relations that hold by summing the boolean lists (the sum of a boolean list is the number of 1's in the list, which is the number of individual relations that hold). To sum the individual relations in the above expressions: +/(c>10)∨(b>10) 3 +/(c>10)∧(b>10) 1 To test whether or not at least one of the individual relations holds: 1≤+/(c>10)∨(b>10) 1 1≤+/(c>10)∧(b>10) 1 (Reading the last expression from left to right: "1 less than or equal to the sum of the relation: c greater than 10 and b greater than 10.") To test whether or not at least two of the individual relations hold: 2≤+/(c>10)∨(b>10) 1 2≤+/(c>10)∧(b>10) 0 Testing whether or not all the individual relations hold can be done in the same general way as above, but it's a little trickier. Besides, it's time to introduce another way to do all these tests (see "8a. Reduction Revisited".) Before continuing with the reduction examples, there is a third logical scalar function to be introduced here, which is the monadic function called Not, or logical negation, and denoted by ∼. The value of ∼0 is 1 and that of ∼x for any nonzero integer x is 0. Both ∧ and ∨ also apply to all integers, not just 0 and 1, but the extended definitions are different in Versions 2 and 3. For Version 3 they are analogous to Not. For Version 2 see the March 1994 A+ Reference Manual. 8a. Reduction Revisited The reduction operator applies to both ∧ and ∨. Like plus and times, ∧ reduction can be defined by putting ∧ between the consecutive elements of a list, as in: ∧/1 1 0 1 0 1∧1∧0∧1 0 ∨ reduction is similar: ∨/1 1 0 1 1 1∨1∨0∨1 1 In order to understand ∧ and ∨ reduction, consider evaluating + reduction by placing the + symbol between all pairs of consecutive elements of a list, as follows: a+b+c+d+e+f+g Compute the sum any pair of consecutive elements, and then replace the + symbol and the two summands with the result. (Any pairs can be used because all the functions that are permitted in reductions are associative.) For example, let h be d+e, so the above expression becomes: a+b+c+h+f+g We now have a list of the same form as the original, but with one fewer element and one fewer + symbol. If the process is repeated, the same thing happens, and eventually all that is left is a single element and no + symbols. That single element is the result of the + reduction. The same procedure works for evaluating ∧ reduction and ∨ reduction. Using it, we can verify the following rule: The result of ∧ reduction is 1 when all the elements in the list are 1, and only then. To verify this rule, consider: 1∧1∧1∧1∧1∧1∧1∧1 1 Evaluate any one of the ∧'s and you get a 1. Replace the 1∧1 you evaluated with that result and you will have the same expression as before, only with one less element and one less ∧. Continue evaluating and eventually you will get to 1. Now put a 0 anywhere in the original list: 1∧1∧1∧1∧0∧1∧1∧1 0 No matter what order you evaluate the individual ∧'s, eventually you must come to either 1∧0 or 0∧1. Either one evaluates to 0, and the 0 replaces either 1∧0 or 0∧1. Either way, there is still a 0 in the list, and eventually you will get to a result of 0. As an exercise, use this line of argument to verify the following rule: The result of ∨ reduction is 0 when all the elements in the list are 0, and only then. Using these rules, we can see how two of the above tests can be rewritten. Namely, the rule for ∨ reduction says that the result of ∨ reduction is 1 if any elements in the list are 1. Consequently, a test of whether or not at least one of the individual relations holds is: ∨/(c>10)∨(b>10) 1 Analogously, a test of whether or not all the individual relations hold is: ∧/(c>10)∨(b>10) 0 8b. Scan Revisited Now that we understand ∧ reduction and ∨ reduction, let's look at ∧ scan and ∨ scan. Starting with ∧ scan, consider the following example: ∧\1 1 1 0 1 1 0 1 1 1 1 0 0 0 0 0 To understand this result, look at the individual ∧ reductions that make it up: ∧/1 1 ∧/1 1 1 ∧/1 1 1 1 ∧/1 1 1 0 0 ∧/1 1 1 0 1 0 ∧/1 1 1 0 1 1 0 ∧/1 1 1 0 1 1 0 0 ∧/1 1 1 0 1 1 0 1 0 Reading the elements of the scan result from the left, all the corresponding elements of the ∧ scan are 1 until the first 0 in the argument is encountered. Once the first 0 is encountered in the argument list, all elements in the scan will be 0 from that point on, no matter what else occurs. As an example of the use of ∧ scan, and based on the above interpretation, if x is a boolean list, then +/∧\x is the index of the first 0. For example: x←1 1 1 0 1 1 0 1 +/∧\x 3 x[0 1 2 3] 1 1 1 0 Consequently, if x represents a list of relations, then +/∧\x is the index of the first relation (reading the list from the left) that fails to hold. For example: m←5 21 ¯7 50 8 p←2 ¯10 20 17 12 p ∣Greater ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣than ∣ ∣ ∣ E ∣ ⍟ ∣Log ∣Natural Log ∣ R ∣ ≥ ∣Greater ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣than or ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣Equal to ∣ ∣ ∣ E ∣ ○ ∣Circle ∣Pi tImes ∣ L ∣ ∧ ∣And ∣ ∣ ∣ ∣ ∣fns ∣ ∣ ∣ ∣ ∣ ∣ ∣ M ∣ ⌈ ∣Max ∣Ceiling ∣ L ∣ ∨ ∣Or ∣ ∣ ∣ M ∣ ⌊ ∣Min ∣Floor ∣ L ∣ ∼ ∣ ∣Not ∣ ∣ M ∣ ∣ ∣Residue ∣Absolute ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣value ∣ ∣ ∣ ∣ ∣ ∣ M ∣ ? ∣ ∣Roll ∣ ∣ ∣ ∣ ∣ ∣ M ∣ ∪ ∣Combine ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣ ∣Symbols ∣ ∣ ∣ ∣ ∣ ∣ ------------------------------------------------------------------------- Table 2: Operators on Scalar Functions ----------------------------------------------------------- ∣Operator ∣Forms ∣ ∣===============∣=========================================∣ ∣Reduction ∣ +/ ×/ ∧/ ∨/ ⌊/ ⌈/ ∣ ∣Scan ∣ +\ ×\ ∧\ ∨\ ⌊\ ⌈\ ∣ ∣Outer Product ∣ ∘.+ ∘.- ∘.× ∘.÷ ∘.∣ ∘.⌊ ∘.⌈∣ ∣ ∣ ∘.= ∘.≠ ∘.< ∘.≤ ∘.> ∘.≥ ∣ ∣Inner Product ∣ +.× ⌊.+ ⌈.+ ∣ ----------------------------------------------------------- \end{verbatim} \end{document}