Commands in this section (like `V A`) prompt you to press the key
corresponding to the desired operator. Press `?` for a partial
list of the available operators. Generally, an operator is any key or
sequence of keys that would normally take one or more arguments from
the stack and replace them with a result. For example, `V A H C`
uses the hyperbolic cosine operator, `cosh`

. (Since `cosh`

expects one argument, `V A H C` requires a vector with a single
element as its argument.)

You can press `x` at the operator prompt to select any algebraic
function by name to use as the operator. This includes functions you
have defined yourself using the `Z F` command. (See Programming with Formulas.) If you give a name for which no function has been
defined, the result is left in symbolic form, as in ‘`f(1, 2, 3)`’.
Calc will prompt for the number of arguments the function takes if it
can’t figure it out on its own (say, because you named a function that
is currently undefined). It is also possible to type a digit key before
the function name to specify the number of arguments, e.g.,
`V M 3 x f RET` calls

`f`

with three arguments even if it
looks like it ought to have only two. This technique may be necessary
if the function allows a variable number of arguments. For example,
the `vexp`

] function accepts two or three arguments;
if you want to map with the three-argument version, you will have to
type It is also possible to apply any formula to a vector by treating that
formula as a function. When prompted for the operator to use, press
`'` (the apostrophe) and type your formula as an algebraic entry.
You will then be prompted for the argument list, which defaults to a
list of all variables that appear in the formula, sorted into alphabetic
order. For example, suppose you enter the formula ‘`x + 2y^x`’.
The default argument list would be ‘`(x y)`’, which means that if
this function is applied to the arguments ‘`[3, 10]`’ the result will
be ‘`3 + 2*10^3`’. (If you plan to use a certain formula in this
way often, you might consider defining it as a function with `Z F`.)

Another way to specify the arguments to the formula you enter is with
`$`, `$$`, and so on. For example, `V A ' $$ + 2$^$$`
has the same effect as the previous example. The argument list is
automatically taken to be ‘`($$ $)`’. (The order of the arguments
may seem backwards, but it is analogous to the way normal algebraic
entry interacts with the stack.)

If you press `$` at the operator prompt, the effect is similar to
the apostrophe except that the relevant formula is taken from top-of-stack
instead. The actual vector arguments of the `V A $` or related command
then start at the second-to-top stack position. You will still be
prompted for an argument list.

A function can be written without a name using the notation ‘`<#1 - #2>`’,
which means “a function of two arguments that computes the first
argument minus the second argument.” The symbols ‘`#1`’ and ‘`#2`’
are placeholders for the arguments. You can use any names for these
placeholders if you wish, by including an argument list followed by a
colon: ‘`<x, y : x - y>`’. When you type `V A ' $$ + 2$^$$ RET`,
Calc builds the nameless function ‘

If there is only one argument, you can write ‘`#`’ in place of ‘`#1`’.
(Note that ‘`< >`’ notation is also used for date forms. Calc tells
that ‘`< stuff>`’ is a nameless function by the presence of
‘

You can type a nameless function directly to `V A '`, or put one on
the stack and use it with `V A $`. Calc will not prompt for an
argument list in this case, since the nameless function specifies the
argument list as well as the function itself. In `V A '`, you can
omit the ‘`< >`’ marks if you use ‘`#`’ notation for the arguments,
so that `V A ' #1+#2 RET` is the same as

The internal format for ‘`<x, y : x + y>`’ is ‘`lambda(x, y, x + y)`’.
(The word `lambda`

derives from Lisp notation and the theory of
functions.) The internal format for ‘`<#1 + #2>`’ is ‘`lambda(ArgA,
ArgB, ArgA + ArgB)`’. Note that there is no actual Calc function called
`lambda`

; the whole point is that the `lambda`

expression is
used in its symbolic form, not evaluated for an answer until it is applied
to specific arguments by a command like `V A` or `V M`.

(Actually, `lambda`

does have one special property: Its arguments
are never evaluated; for example, putting ‘`<(2/3) #>`’ on the stack
will not simplify the ‘`2/3`’ until the nameless function is actually
called.)

As usual, commands like `V A` have algebraic function name equivalents.
For example, `V A k g` with an argument of ‘`v`’ is equivalent to
‘`apply(gcd, v)`’. The first argument specifies the operator name,
and is either a variable whose name is the same as the function name,
or a nameless function like ‘`<#^3+1>`’. Operators that are normally
written as algebraic symbols have the names `add`

, `sub`

,
`mul`

, `div`

, `pow`

, `neg`

, `mod`

, and
`vconcat`

.

The `call`

function builds a function call out of several arguments:
‘`call(gcd, x, y)`’ is the same as ‘`apply(gcd, [x, y])`’, which
in turn is the same as ‘`gcd(x, y)`’. The first argument of `call`

,
like the other functions described here, may be either a variable naming a
function, or a nameless function (‘`call(<#1+2#2>, x, y)`’ is the same
as ‘`x + 2y`’).

(Experts will notice that it’s not quite proper to use a variable to name
a function, since the name `gcd`

corresponds to the Lisp variable
`var-gcd`

but to the Lisp function `calcFunc-gcd`

. Calc
automatically makes this translation, so you don’t have to worry
about it.)