Previous: Matrix Tutorial, Up: Vector/Matrix Tutorial [Contents][Index]

#### 2.3.3 Vectors as Lists

Although Calc has a number of features for manipulating vectors and matrices as mathematical objects, you can also treat vectors as simple lists of values. For example, we saw that the `k f` command returns a vector which is a list of the prime factors of a number.

You can pack and unpack stack entries into vectors:

    3:  10         1:  [10, 20, 30]     3:  10
    2:  20             .                2:  20
    1:  30                              1:  30
        .                                   .

                       M-3 v p              v u

You can also build vectors out of consecutive integers, or out of many copies of a given value:

    1:  [1, 2, 3, 4]    2:  [1, 2, 3, 4]    2:  [1, 2, 3, 4]
        .               1:  17              1:  [17, 17, 17, 17]
                            .                   .

        v x 4 RET           17                  v b 4 RET

You can apply an operator to every element of a vector using the map command.

    1:  [17, 34, 51, 68]   1:  [289, 1156, 2601, 4624]  1:  [17, 34, 51, 68]
        .                      .                            .

        V M *                  2 V M ^                      V M Q

In the first step, we multiply the vector of integers by the vector of 17’s elementwise. In the second step, we raise each element to the power two. (The general rule is that both operands must be vectors of the same length, or else one must be a vector and the other a plain number.) In the final step, we take the square root of each element.

(•) Exercise 1. Compute a vector of powers of two from ‘`2^-4`’ to ‘`2^4`’. See 1. (•)

You can also reduce a binary operator across a vector. For example, reducing ‘`*`’ computes the product of all the elements in the vector:

    1:  123123     1:  [3, 7, 11, 13, 41]      1:  123123
        .              .                           .

        123123         k f                         V R *

In this example, we decompose 123123 into its prime factors, then multiply those factors together again to yield the original number.

We could compute a dot product “by hand” using mapping and reduction:

    2:  [1, 2, 3]     1:  [7, 12, 0]     1:  19
    1:  [7, 6, 0]         .                  .
        .

        r 1 r 2           V M *              V R +

Recalling two vectors from the previous section, we compute the sum of pairwise products of the elements to get the same answer for the dot product as before.

A slight variant of vector reduction is the accumulate operation, `V U`. This produces a vector of the intermediate results from a corresponding reduction. Here we compute a table of factorials:

    1:  [1, 2, 3, 4, 5, 6]    1:  [1, 2, 6, 24, 120, 720]
        .                         .

        v x 6 RET                 V U *

Calc allows vectors to grow as large as you like, although it gets rather slow if vectors have more than about a hundred elements. Actually, most of the time is spent formatting these large vectors for display, not calculating on them. Try the following experiment (if your computer is very fast you may need to substitute a larger vector size).

    1:  [1, 2, 3, 4, ...      1:  [2, 3, 4, 5, ...
        .                         .

        v x 500 RET               1 V M +

Now press `v .` (the letter `v`, then a period) and try the experiment again. In `v .` mode, long vectors are displayed “abbreviated” like this:

    1:  [1, 2, 3, ..., 500]   1:  [2, 3, 4, ..., 501]
        .                         .

        v x 500 RET               1 V M +

(where now the ‘`...`’ is actually part of the Calc display). You will find both operations are now much faster. But notice that even in `v .` mode, the full vectors are still shown in the Trail. Type `t .` to cause the trail to abbreviate as well, and try the experiment one more time. Operations on long vectors are now quite fast! (But of course if you use `t .` you will lose the ability to get old vectors back using the `t y` command.)

An easy way to view a full vector when `v .` mode is active is to press ``` (grave accent) to edit the vector; editing always works with the full, unabbreviated value.

As a larger example, let’s try to fit a straight line to some data, using the method of least squares. (Calc has a built-in command for least-squares curve fitting, but we’ll do it by hand here just to practice working with vectors.) Suppose we have the following list of values in a file we have loaded into Emacs:

      x        y
     ---      ---
     1.34    0.234
     1.41    0.298
     1.49    0.402
     1.56    0.412
     1.64    0.466
     1.73    0.473
     1.82    0.601
     1.91    0.519
     2.01    0.603
     2.11    0.637
     2.22    0.645
     2.33    0.705
     2.45    0.917
     2.58    1.009
     2.71    0.971
     2.85    1.062
     3.00    1.148
     3.15    1.157
     3.32    1.354

If you are reading this tutorial in printed form, you will find it easiest to press `C-x * i` to enter the on-line Info version of the manual and find this table there. (Press `g`, then type `List Tutorial`, to jump straight to this section.)

Position the cursor at the upper-left corner of this table, just to the left of the ‘`1.34`’. Press `C-@` to set the mark. (On your system this may be `C-2`, `C-SPC`, or `NUL`.) Now position the cursor to the lower-right, just after the ‘`1.354`’. You have now defined this region as an Emacs “rectangle.” Still in the Info buffer, type `C-x * r`. This command (`calc-grab-rectangle`) will pop you back into the Calculator, with the contents of the rectangle you specified in the form of a matrix.

    1:  [ [ 1.34, 0.234 ]
          [ 1.41, 0.298 ]
          …

(You may wish to use `v .` mode to abbreviate the display of this large matrix.)

We want to treat this as a pair of lists. The first step is to transpose this matrix into a pair of rows. Remember, a matrix is just a vector of vectors. So we can unpack the matrix into a pair of row vectors on the stack.

    1:  [ [ 1.34,  1.41,  1.49,  ... ]     2:  [1.34, 1.41, 1.49, ... ]
          [ 0.234, 0.298, 0.402, ... ] ]   1:  [0.234, 0.298, 0.402, ... ]
        .                                      .

        v t                                    v u

Let’s store these in quick variables 1 and 2, respectively.

    1:  [1.34, 1.41, 1.49, ... ]        .
        .

        t 2                             t 1

(Recall that `t 2` is a variant of `s 2` that removes the stored value from the stack.)

In a least squares fit, the slope ‘`m`’ is given by the formula

    m = (N sum(x y) - sum(x) sum(y)) / (N sum(x^2) - sum(x)^2)

where ‘`sum(x)`’ represents the sum of all the values of ‘`x`’. While there is an actual `sum` function in Calc, it’s easier to sum a vector using a simple reduction. First, let’s compute the four different sums that this formula uses.

    1:  41.63                 1:  98.0003
        .                         .

     r 1 V R +   t 3           r 1 2 V M ^ V R +   t 4

    1:  13.613                1:  33.36554
        .                         .

     r 2 V R +   t 5           r 1 r 2 V M * V R +   t 6

These are ‘`sum(x)`’, ‘`sum(x^2)`’, ‘`sum(y)`’, and ‘`sum(x y)`’, respectively. (We could have used `*` to compute ‘`sum(x^2)`’ and ‘`sum(x y)`’.)

Finally, we also need ‘`N`’, the number of data points. This is just the length of either of our lists.

    1:  19
        .

     r 1 v l   t 7

(That’s `v` followed by a lower-case `l`.)

Now we grind through the formula:

    1:  633.94526  2:  633.94526  1:  67.23607
        .          1:  566.70919      .
                       .

     r 7 r 6 *      r 3 r 5 *         -

    2:  67.23607   3:  67.23607   2:  67.23607   1:  0.52141679
    1:  1862.0057  2:  1862.0057  1:  128.9488       .
        .          1:  1733.0569      .
                       .

     r 7 r 4 *      r 3 2 ^           -              /   t 8

That gives us the slope ‘`m`’. The y-intercept ‘`b`’ can now be found with the simple formula,

    b = (sum(y) - m sum(x)) / N

    1:  13.613     2:  13.613     1:  -8.09358   1:  -0.425978
        .          1:  21.70658       .              .
                       .

       r 5            r 8 r 3 *       -              r 7 /   t 9

Let’s “plot” this straight line approximation, ‘`m x + b`’, and compare it with the original data.

    1:  [0.699, 0.735, ... ]    1:  [0.273, 0.309, ... ]
        .                           .

        r 1 r 8 *                   r 9 +    s 0

Notice that multiplying a vector by a constant, and adding a constant to a vector, can be done without mapping commands since these are common operations from vector algebra. As far as Calc is concerned, we’ve just been doing geometry in 19-dimensional space!

We can subtract this vector from our original ‘`y`’ vector to get a feel for the error of our fit. Let’s find the maximum error:

    1:  [0.0387, 0.0112, ... ]   1:  [0.0387, 0.0112, ... ]   1:  0.0897
        .                            .                            .

        r 2 -                        V M A                        V R X

First we compute a vector of differences, then we take the absolute values of these differences, then we reduce the `max` function across the vector. (The `max` function is on the two-key sequence `f x`; because it is so common to use `max` in a vector operation, the letters `X` and `N` are also accepted for `max` and `min` in this context. In general, you answer the `V M` or `V R` prompt with the actual key sequence that invokes the function you want. You could have typed `V R f x` or even `V R x max RET` if you had preferred.)

If your system has the GNUPLOT program, you can see graphs of your data and your straight line to see how well they match. (If you have GNUPLOT 3.0 or higher, the following instructions will work regardless of the kind of display you have. Some GNUPLOT 2.0, non-X-windows systems may require additional steps to view the graphs.)

Let’s start by plotting the original data. Recall the “x” and “y” vectors onto the stack and press `g f`. This “fast” graphing command does everything you need to do for simple, straightforward plotting of data.

    2:  [1.34, 1.41, 1.49, ... ]
    1:  [0.234, 0.298, 0.402, ... ]
        .

        r 1 r 2    g f

If all goes well, you will shortly get a new window containing a graph of the data. (If not, contact your GNUPLOT or Calc installer to find out what went wrong.) In the X window system, this will be a separate graphics window. For other kinds of displays, the default is to display the graph in Emacs itself using rough character graphics. Press `q` when you are done viewing the character graphics.

Next, let’s add the line we got from our least-squares fit.

    2:  [1.34, 1.41, 1.49, ... ]
    1:  [0.273, 0.309, 0.351, ... ]
        .

        DEL r 0    g a  g p

It’s not very useful to get symbols to mark the data points on this second curve; you can type `g S g p` to remove them. Type `g q` when you are done to remove the X graphics window and terminate GNUPLOT.

(•) Exercise 2. An earlier exercise showed how to do least squares fitting to a general system of equations. Our 19 data points are really 19 equations of the form ‘`y_i = m x_i + b`’ for different pairs of ‘`(x_i,y_i)`’. Use the matrix-transpose method to solve for ‘`m`’ and ‘`b`’, duplicating the above result. See 2. (•)

(•) Exercise 3. If the input data do not form a rectangle, you can use `C-x * g` (`calc-grab-region`) to grab the data the way Emacs normally works with regions—it reads left-to-right, top-to-bottom, treating line breaks the same as spaces. Use this command to find the geometric mean of the following numbers. (The geometric mean is the nth root of the product of n numbers.)

    2.3  6  22  15.1  7
      15  14  7.5
      2.5

The `C-x * g` command accepts numbers separated by spaces or commas, with or without surrounding vector brackets. See 3. (•)

As another example, a theorem about binomial coefficients tells us that the alternating sum of binomial coefficients n-choose-0 minus n-choose-1 plus n-choose-2, and so on up to n-choose-n, always comes out to zero. Let’s verify this for ‘`n=6`’.

    1:  [1, 2, 3, 4, 5, 6, 7]     1:  [0, 1, 2, 3, 4, 5, 6]
        .                             .

        v x 7 RET                     1 -

    1:  [1, -6, 15, -20, 15, -6, 1]          1:  0
        .                                        .

        V M ' (-1)^$ choose(6,$) RET             V R +

The `V M '` command prompts you to enter any algebraic expression to define the function to map over the vector. The symbol ‘`$`’ inside this expression represents the argument to the function. The Calculator applies this formula to each element of the vector, substituting each element’s value for the ‘`$`’ sign(s) in turn.

To define a two-argument function, use ‘`$$`’ for the first argument and ‘`$`’ for the second: `V M ' $$-$ RET` is equivalent to `V M -`. This is analogous to regular algebraic entry, where ‘`$$`’ would refer to the next-to-top stack entry and ‘`$`’ would refer to the top stack entry, and `' $$-$ RET` would act exactly like `-`.

Notice that the `V M '` command has recorded two things in the trail: The result, as usual, and also a funny-looking thing marked ‘`oper`’ that represents the operator function you typed in. The function is enclosed in ‘`< >`’ brackets, and the argument is denoted by a ‘`#`’ sign. If there were several arguments, they would be shown as ‘`#1`’, ‘`#2`’, and so on. (For example, `V M ' $$-$` will put the function ‘`<#1 - #2>`’ on the trail.) This object is a “nameless function”; you can use nameless ‘`< >`’ notation to answer the `V M '` prompt if you like. Nameless function notation has the interesting, occasionally useful property that a nameless function is not actually evaluated until it is used. For example, `V M ' $+random(2.0)` evaluates ‘`random(2.0)`’ once and adds that random number to all elements of the vector, but `V M ' <#+random(2.0)>` evaluates the ‘`random(2.0)`’ separately for each vector element.

Another group of operators that are often useful with `V M` are the relational operators: `a =`, for example, compares two numbers and gives the result 1 if they are equal, or 0 if not. Similarly, `a <` checks for one number being less than another.

Other useful vector operations include `v v`, to reverse a vector end-for-end; `V S`, to sort the elements of a vector into increasing order; and `v r` and `v c`, to extract one row or column of a matrix, or (in both cases) to extract one element of a plain vector. With a negative argument, `v r` and `v c` instead delete one row, column, or vector element.

(•) Exercise 4. The ‘`k`’th divisor function is the sum of the ‘`k`’th powers of all the divisors of an integer ‘`n`’. Figure out a method for computing the divisor function for reasonably small values of ‘`n`’. As a test, the 0th and 1st divisor functions of 30 are 8 and 72, respectively. See 4. (•)

(•) Exercise 5. The `k f` command produces a list of prime factors for a number. Sometimes it is important to know that a number is square-free, i.e., that no prime occurs more than once in its list of prime factors. Find a sequence of keystrokes to tell if a number is square-free; your method should leave 1 on the stack if it is, or 0 if it isn’t. See 5. (•)

(•) Exercise 6. Build a list of lists that looks like the following diagram. (You may wish to use the `v /` command to enable multi-line display of vectors.)

    1:  [ [1],
          [1, 2],
          [1, 2, 3],
          [1, 2, 3, 4],
          [1, 2, 3, 4, 5],
          [1, 2, 3, 4, 5, 6] ]

See 6. (•)

(•) Exercise 7. Build the following list of lists.

    1:  [ [0],
          [1, 2],
          [3, 4, 5],
          [6, 7, 8, 9],
          [10, 11, 12, 13, 14],
          [15, 16, 17, 18, 19, 20] ]

See 7. (•)

(•) Exercise 8. Compute a list of values of Bessel’s ‘`J1`’ function ‘`besJ(1,x)`’ for ‘`x`’ from 0 to 5 in steps of 0.25. Find the value of ‘`x`’ (from among the above set of values) for which ‘`besJ(1,x)`’ is a maximum. Use an “automatic” method, i.e., just reading along the list by hand to find the largest value is not allowed! (There is an `a X` command which does this kind of thing automatically; see Numerical Solutions.) See 8. (•)

(•) Exercise 9. You are given an integer in the range ‘`0 <= N < 10^m`’ for ‘`m=12`’ (i.e., an integer of less than twelve digits). Convert this integer into a vector of ‘`m`’ digits, each in the range from 0 to 9. In vector-of-digits notation, add one to this integer to produce a vector of ‘`m+1`’ digits (since there could be a carry out of the most significant digit). Convert this vector back into a regular integer. A good integer to try is 25129925999. See 9. (•)

(•) Exercise 10. Your friend Joe tried to use `V R a =` to test if all numbers in a list were equal. What happened? How would you do this test? See 10. (•)

(•) Exercise 11. The area of a circle of radius one is ‘`pi`’. The area of the 2x2 square that encloses that circle is 4. So if we throw n darts at random points in the square, about ‘`pi/4`’ of them will land inside the circle. This gives us an entertaining way to estimate the value of ‘`pi`’. The `k r` command picks a random number between zero and the value on the stack. We could get a random floating-point number between -1 and 1 by typing `2.0 k r 1 -`. Build a vector of 100 random ‘`(x,y)`’ points in this square, then use vector mapping and reduction to count how many points lie inside the unit circle. Hint: Use the `v b` command. See 11. (•)

(•) Exercise 12. The matchstick problem provides another way to calculate ‘`pi`’. Say you have an infinite field of vertical lines with a spacing of one inch. Toss a one-inch matchstick onto the field. The probability that the matchstick will land crossing a line turns out to be ‘`2/pi`’. Toss 100 matchsticks to estimate ‘`pi`’. (If you want still more fun, the probability that the GCD (`k g`) of two large integers is one turns out to be ‘`6/pi^2`’. That provides yet another way to estimate ‘`pi`’.) See 12. (•)

(•) Exercise 13. An algebraic entry of a string in double-quote marks, ‘`"hello"`’, creates a vector of the numerical (ASCII) codes of the characters (here, ‘`[104, 101, 108, 108, 111]`’). Sometimes it is convenient to compute a hash code of a string, which is just an integer that represents the value of that string. Two equal strings have the same hash code; two different strings probably have different hash codes. (For example, Calc has over 400 function names, but Emacs can quickly find the definition for any given name because it has sorted the functions into “buckets” by their hash codes. Sometimes a few names will hash into the same bucket, but it is easier to search among a few names than among all the names.) One popular hash function is computed as follows: First set ‘`h = 0`’. Then, for each character from the string in turn, set ‘`h = 3h + c_i`’ where ‘`c_i`’ is the character’s ASCII code. If we have 511 buckets, we then take the hash code modulo 511 to get the bucket number. Develop a simple command or commands for converting string vectors into hash codes. The hash code for ‘`"Testing, 1, 2, 3"`’ is 1960915098, which modulo 511 is 121. See 13. (•)

(•) Exercise 14. The `H V R` and `H V U` commands do nested function evaluations. `H V U` takes a starting value and a number of steps n from the stack; it then applies the function you give to the starting value 0, 1, 2, up to n times and returns a vector of the results. Use this command to create a “random walk” of 50 steps. Start with the two-dimensional point ‘`(0,0)`’; then take one step a random distance between -1 and 1 in both ‘`x`’ and ‘`y`’; then take another step, and so on. Use the `g f` command to display this random walk. Now modify your random walk to walk a unit distance, but in a random direction, at each step. (Hint: The `sincos` function returns a vector of the cosine and sine of an angle.) See 14. (•)

Previous: Matrix Tutorial, Up: Vector/Matrix Tutorial [Contents][Index]