Next: Yanking Into Buffers, Previous: Inserting From Registers, Up: Kill and Yank [Contents][Index]

### 14.5 Grabbing from Other Buffers

The `C-x * g` (`calc-grab-region`) command takes the text between point and mark in the current buffer and attempts to parse it as a vector of values. Basically, it wraps the text in vector brackets ‘`[ ]`’ unless the text already is enclosed in vector brackets, then reads the text as if it were an algebraic entry. The contents of the vector may be numbers, formulas, or any other Calc objects. If the `C-x * g` command works successfully, it does an automatic `C-x * c` to enter the Calculator buffer.

A numeric prefix argument grabs the specified number of lines around point, ignoring the mark. A positive prefix grabs from point to the ‘`n`’th following newline (so that `M-1 C-x * g` grabs from point to the end of the current line); a negative prefix grabs from point back to the ‘`n+1`’st preceding newline. In these cases the text that is grabbed is exactly the same as the text that `C-k` would delete given that prefix argument.

A prefix of zero grabs the current line; point may be anywhere on the line.

A plain `C-u` prefix interprets the region between point and mark as a single number or formula rather than a vector. For example, `C-x * g` on the text ‘`2 a b`’ produces the vector of three values ‘`[2, a, b]`’, but `C-u C-x * g` on the same region reads a formula which is a product of three things: ‘`2 a b`’. (The text ‘`a + b`’, on the other hand, will be grabbed as a vector of one element by plain `C-x * g` because the interpretation ‘`[a, +, b]`’ would be a syntax error.)

If a different language has been specified (see Language Modes), the grabbed text will be interpreted according to that language.

The `C-x * r` (`calc-grab-rectangle`) command takes the text between point and mark and attempts to parse it as a matrix. If point and mark are both in the leftmost column, the lines in between are parsed in their entirety. Otherwise, point and mark define the corners of a rectangle whose contents are parsed.

Each line of the grabbed area becomes a row of the matrix. The result will actually be a vector of vectors, which Calc will treat as a matrix only if every row contains the same number of values.

If a line contains a portion surrounded by square brackets (or curly braces), that portion is interpreted as a vector which becomes a row of the matrix. Any text surrounding the bracketed portion on the line is ignored.

Otherwise, the entire line is interpreted as a row vector as if it were surrounded by square brackets. Leading line numbers (in the format used in the Calc stack buffer) are ignored. If you wish to force this interpretation (even if the line contains bracketed portions), give a negative numeric prefix argument to the `C-x * r` command.

If you give a numeric prefix argument of zero or plain `C-u`, each line is instead interpreted as a single formula which is converted into a one-element vector. Thus the result of `C-u C-x * r` will be a one-column matrix. For example, suppose one line of the data is the expression ‘`2 a`’. A plain `C-x * r` will interpret this as ‘`[2 a]`’, which in turn is read as a two-element vector that forms one row of the matrix. But a `C-u C-x * r` will interpret this row as ‘`[2*a]`’.

If you give a positive numeric prefix argument n, then each line will be split up into columns of width n; each column is parsed separately as a matrix element. If a line contained ‘`2 +/- 3 4 +/- 5`’, then grabbing with a prefix argument of 8 would correctly split the line into two error forms.

See Matrix Functions, to see how to pull the matrix apart into its constituent rows and columns. (If it is a 1x1 matrix, just hit `v u` (`calc-unpack`) twice.)

The `C-x * :` (`calc-grab-sum-down`) command is a handy way to grab a rectangle of data and sum its columns. It is equivalent to typing `C-x * r`, followed by `V R : +` (the vector reduction command that sums the columns of a matrix; see Reducing). The result of the command will be a vector of numbers, one for each column in the input data. The `C-x * _` (`calc-grab-sum-across`) command similarly grabs a rectangle and sums its rows by executing `V R _ +`.

As well as being more convenient, `C-x * :` and `C-x * _` are also much faster because they don’t actually place the grabbed vector on the stack. In a `C-x * r V R : +` sequence, formatting the vector for display on the stack takes a large fraction of the total time (unless you have planned ahead and used `v .` and `t .` modes).

For example, suppose we have a column of numbers in a file which we wish to sum. Go to one corner of the column and press `C-@` to set the mark; go to the other corner and type `C-x * :`. Since there is only one column, the result will be a vector of one number, the sum. (You can type `v u` to unpack this vector into a plain number if you want to do further arithmetic with it.)

To compute the product of the column of numbers, we would have to do it “by hand” since there’s no special grab-and-multiply command. Use `C-x * r` to grab the column of numbers into the calculator in the form of a column matrix. The statistics command `u *` is a handy way to find the product of a vector or matrix of numbers. See Statistical Operations. Another approach would be to use an explicit column reduction command, `V R : *`.

Next: Yanking Into Buffers, Previous: Inserting From Registers, Up: Kill and Yank [Contents][Index]