SC(1)SC(1)NAMEsc - spreadsheet calculator
SYNOPSISsc [ -c ] [ -m ] [ -n ] [ -r ] [ -x ] [ file ]
DESCRIPTION
The spreadsheet calculator sc is based on rectangular tables much like
a financial spreadsheet. When invoked it presents you with a table
organized as rows and columns of cells. If invoked without a file
argument, the table is initially empty. Otherwise file is read in (see
the Get command below). Each cell may have associated with it a
numeric value, a label string, and/or an expression (formula) which
evaluates to a numeric value or label string, often based on other cell
values.
Options are:
-c Start the program with the recalculation being done in column
order.
-m Start the program with automatic recalculation disabled. The
spreadsheet will be recalculated only when the ``@'' command is
used.
-n Start the program in quick numeric entry mode (see below).
-r Start the program with the recalculation being done in row order
(default option).
-x Cause the Get and Put commands (see below) to encrypt and
decrypt data files.
All of these options can be changed with the ^T and S commands (see
below) while sc is running. Options specified when sc is invoked over‐
ride options saved in the data file.
General Information
The screen is divided into four regions. The top line is for entering
commands and displaying cell values. The second line is for messages
from sc. The third line and the first four columns show the column and
row numbers, from which are derived cell addresses, e.g. A0 for the
cell in column A, row 0. Note that column names are case-insensitive:
you can enter A0 or a0.
The rest of the screen forms a window looking at a portion of the ta‐
ble. The total number of display rows and columns available, hence the
number of table rows and columns displayed, is set by curses(3) and may
be overridden by setting the LINES and COLUMNS environment variables,
respectively.
The screen has two cursors: a cell cursor, indicated by a highlighted
cell and a ``<'' on the screen, and a character cursor, indicated by
the terminal's hardware cursor. The cell and character cursors are
often the same. They differ when you type a command on the top line.
If a cell's numeric value is wider than the column width (see the f
command), the cell is filled with asterisks. If a cell's label string
is wider than the column width, it is truncated at the start of the
next non-blank cell in the row, if any.
Cursor control commands and row and column commands can be prefixed by
a numeric argument which indicates how many times the command is to be
executed. You can type ^U before a repeat count if quick numeric entry
mode is enabled or if the number is to be entered while the character
cursor is on the top line.
Commands which use the terminal's control key, such as ^N, work both
when a command is being typed and when in normal mode.
Changing Options
^To Toggle options. This command allows you to switch the state of
one option selected by o. A small menu lists the choices for o
when you type ^T. The options selected are saved when the data
and formulas are saved so that you will have the same setup next
time you enter the spreadsheet.
a Automatic Recalculation. When set, each change in the
spreadsheet causes the entire spreadsheet be recalcu‐
lated. Normally this is not noticeable, but for very
large spreadsheets, it may be faster to clear automatic
recalculation mode and update the spreadsheet via
explicit ``@'' commands. Default is automatic recalcula‐
tion on.
c Current cell highlighting. If enabled, the current cell
is highlighted (using the terminal's standout mode, if
available) in addition to being marked by the cell cur‐
sor.
e External function execution. When disabled, external
functions (see @ext() below) are not called. This saves
a lot of time at each screen update. External functions
are disabled by default. If disabled, and external func‐
tions are used anywhere, a warning is printed each time
the screen is updated, and the result of @ext() is the
value from the previous call, if any, or a null string.
n Quick numeric entry. If enabled, a typed digit is
assumed to be the start of a numeric value for the cur‐
rent cell, not a repeat count, unless preceded by ^U.
t Top line display. If enabled, the name and value of the
current cell is displayed on the top line. If there is
an associated label string, the first character of the
string value is ``<'' for a leftstring or ``>'' for a
rightstring (see below), followed by "string" for a con‐
stant string or {expr} for a string expression. If the
cell has a numeric value, it follows as [value], which
may be a constant or expression.
x Encryption. See the -x option.
$ Dollar prescale. If enabled, all numeric constants (not
expressions) which you enter are multipled by 0.01 so you
don't have to keep typing the decimal point if you enter
lots of dollar figures.
S Set options. This command allows you to set various options. A
small menu lists the options that cannot be changed through ^T
above.
byrows/bycols
Specify the order cell evaluation when updating. These
options also affect the order in which cells are filled
(see /f) and whether a row or column is cleared by an x
command.
iterations=n
Set the maximum number of recalculations before the
screen is displayed again. Iterations is set to 10 by
default.
tblstyle=s
Control the output of the T command. s can be: 0
(default) to give colon delimited fields, with no tbl
control lines; tbl to give colon delimited fields, with
tbl(1) control lines; latex to give a LaTeX tabular envi‐
ronment; and tex to give a TeX simple tabbed alignment
with ampersands as delimiters.
Other Set options are normally used only in sc data files since
they are available through ^T. You can also use them interac‐
tively
autocalc/!autocalc
Set/clear auto recalculation mode.
numeric/!numeric
Set/clear numeric mode.
prescale/!prescale
Set/clear numeric prescale mode.
extfun/!extfun
Enable/disable external functions.
cellcur/!cellcur
Set/clear current cell highlighting mode.
toprow/!toprow
Set/clear top row display mode.
Cursor Control Commands
^P Move the cell cursor up to the previous row.
^N Move the cell cursor down to the next row.
^B Move the cell cursor backward one column.
^F Move the cell cursor forward one column.
h, j, k, l
If the character cursor is not on the top line, these are alter‐
nate, vi-compatible cell cursor controls (left, down, up,
right).
^H If the character cursor is not on the top line, ^H is the same
as ^B.
SPACE If the character cursor is not on the top line, the space bar is
the same as ^F.
TAB If the character cursor is on the top line, TAB starts a range
(see below). Otherwise, it is the same as ^F.
Arrow Keys
The terminal's arrow keys provide another alternate set of cell
cursor controls if they exist and are supported in the appropri‐
ate termcap entry. Some terminals have arrow keys which con‐
flict with other control key codes. For example, a terminal
might send ^H when the back arrow key is pressed. In these
cases, the conflicting arrow key performs the same function as
the key combination it mimics.
^ Move the cell cursor up to row 0 of the current column.
# Move the cell cursor down to the last valid row of the current
column.
0 Move the cell cursor backward to column A of the current row.
This command must be prefixed with ^U if quick numeric entry
mode is enabled.
$ Move the cell cursor forward to the last valid column of the
current row.
b Scan the cursor backward (left and up) to the previous valid
cell.
w Scan the cursor forward (right and down) to the next valid cell.
^Ed Go to end of range. Follow ^E by a direction indicator such as
^P or j. If the cell cursor starts on a non-blank cell, it goes
in the indicated direction until the last non-blank adjacent
cell. If the cell cursor starts on a blank cell, it goes in the
indicated direction until the first non-blank cell. This com‐
mand is useful when specifying ranges of adjacent cells (see
below), especially when the range is bigger than the visible
window.
g Go to a cell. sc prompts for a cell's name, a regular expres‐
sion surrounded by quotes, or a number. If a cell's name such
as ae122 or a the name of a defined range is given, the cell
cursor goes directly to that cell. If a quoted regular expres‐
sion such as " Tax Table " or " ^Jan [0-9]*$ " is given, sc
searches for a cell containing a string matching the regular
expression. See regex(3) or ed(1) for more details on the form
of regular expressions. If a number is given, sc will search
for a cell containing that number. Searches for either strings
or numbers proceed forward from the current cell, wrapping back
to a0 at the end of the table, and terminate at the current cell
if the string or number is not found. The last g command is
saved, and can be re-issued by entering g<return>.
Cell Entry and Editing Commands
Cells can contain both a numeric value and a string value. Either
value can be the result of an expression, but not both at once, i.e.
each cell can have only one expression associated with it. Entering a
valid numeric expression alters the cell's previous numeric value, if
any, and replaces the cell's previous string expression, if any, leav‐
ing only the previously computed constant label string. Likewise,
entering a valid string expression alters the cell's the previous label
string, if any, and replaces the cell's previous numeric expression, if
any, leaving only the previously computed constant numeric value.
= Enter a numeric constant or expression into the current cell.
sc prompts for the expression on the top line. The usual way to
enter a number into a cell is to type ``='', then enter the num‐
ber in response to the prompt on the top line. The quick
numeric entry option, enabled through the -n option or ^T com‐
mand, shows the prompt when you enter the first digit of a num‐
ber (you can skip typing ``='').
< Enter a label string into the current cell to be flushed left
against the left edge of the cell.
"
> Enter a label string into the current cell to be flushed right
against the right edge of the cell.
Strings you enter must start with ". You can leave off the trailing "
and sc will add it for you. You can also enter a string expression by
backspacing over the opening " in the prompt.
e Edit the value associated with the current cell. This is iden‐
tical to ``='' except that the command line starts out contain‐
ing the old numeric value or expression associated with the
cell.
E Edit the string associated with the current cell. This is iden‐
tical to ``<'', ``"'', or ``>'' except that the command line
starts out containing the old string value or expression associ‐
ated with the cell.
To enter and edit a cell's number part, use the ``='' and e commands.
To enter and edit a cell's string part, use the ``<'', ``"'', ``>'',
and E commands. See the sections below on numeric and string expres‐
sions for more information.
x Clear the current cell. Deletes the numeric value, label
string, and/or numeric or string expression. You can prefix
this command with a count of the number of cells on the current
row to clear. The current column is used if column recalcula‐
tion order is set. Cells cleared with this command may be
recalled with any of the pull commands (see below).
m Mark a cell to be used as the source for the copy command.
c Copy the last marked cell to the current cell, updating row and
column references in its numeric or string expression, if any.
+ If not in numeric mode, add the current numeric argument
(default 1) to the value of the current cell. In numeric mode,
``+'' introduces a new numeric expression or value, the same as
``=''.
- If not in numeric mode, subtract the current numeric argument
(default 1) from the value of the current cell. In numeric
mode, ``-'' introduces a new, negative, numeric expression or
value, like ``=''.
File Commands
G Get a new database from a file. If encryption is enabled, the
file is decrypted before it is loaded into the spreadsheet.
P Put the current database into a file. If encryption is enabled,
the file is encrypted before it is saved.
W Write a listing of the current database into a file in a form
that matches its appearance on the screen. This differs from
the Put command in that its files are intended to be reloaded
with Get, while Write produces a file for people to look at.
Hidden rows or columns are not shown when the data is printed.
T Write a listing of the current database to a file, but include
delimiters suitable for processing by the tbl, LaTeX, or TeX ta‐
ble processors. The delimiters are controlled by the tblstyle
option. See Set above. The delimters are are a colon (:) for
style 0ortbl and an ampersand (&) for style latexortex.
With the Put, Write, and Table commands, the optional range argument
writes a subset of the spreadsheet to the output file.
With the Write and Table commands, if you try to write to the last file
used with the Get or Put commands, or the file specified on the command
line when sc was invoked, you are asked to confirm that the (poten‐
tially) dangerous operation is really what you want.
The three output commands, Put, Write, and Table, can pipe their (unen‐
crypted only) output to a program. To use this feature, enter ``| pro‐
gram'' to the prompt asking for a filename. For example, to redirect
the output of the Write command to the printer, you might enter ``| lpr
-p''.
M Merge the database from the named file into the current data‐
base. Values and expressions defined in the named file are read
into the current spreadsheet overwriting the existing entries at
matching cell locations.
R Run macros. Since sc files are saved as ASCII files, it is pos‐
sible to use them as primitive macro definition files. The Run
command makes this easier. It's like the Merge command, but
prints a saved path name as the start of the filename to merge
in. The string to use is set with the Define command. To write
macros, you must be familiar with the file format written by the
Put command. This facility is still primitive and could be much
improved.
D Define a path for the Run command to use.
All file operations take a filename as the first argument to the prompt
on the top line. The prompt supplies a " to aid in typing in the file‐
name. The filename can also be obtained from a cell's label string or
string expression. In this case, delete the leading " with the
backspace key and enter a cell name such as a22 instead. If the
resulting string starts with ``|'', the rest of the string is inter‐
preted as a UNIX command, as above.
Row and Column Commands
These commands can be used on either rows or columns. The second let‐
ter of the command is either a row designator (one of the characters r,
^B, ^F, h, l) or a column designator (one of c, ^P, ^N, k, j). A small
menu lists the choices for the second letter when you type the first
letter of one of these commands. Commands which move or copy cells
also modify the row and column references in affected cell expressions.
The references may be frozen by using the fixed operator or using the $
character in the reference to the cell (see below).
ir, ic Insert a new row (column) by moving the row (column) containing
the cell cursor, and all following rows (columns), down (right)
one row (column). The new row (column) is empty.
ar, ac Append a new row (column) immediately following the current row
(column). It is initialized as a copy of the current one.
dr, dc Delete the current row (column).
pr, pc, pm
Pull deleted rows (columns) back into the spreadsheet. The last
deleted set of cells is put back into the spreadsheet at the
current location. pr inserts enough rows to hold the data. pc
inserts enough columns to hold the data. pm (merge) does not
insert rows or columns; it overwrites the cells beginning at the
current cell cursor location.
vr, vc Remove expressions from the affected rows (columns), leaving
only the values which were in the cells before the command was
executed.
zr, zc Hide (``zap'') the current row (column). This keeps a row (col‐
umn) from being displayed but keeps it in the data base. The
status of the rows and columns is saved with the data base so
hidden rows and columns will be still be hidden when you reload
the spreadsheet. Hidden rows or columns are not printed by the
W command.
sr, sc Show hidden rows (columns). Enter a range of rows (columns) to
be revealed. The default is the first range of rows (columns)
currently hidden. This command ignores the repeat count, if
any.
f Set the output format to be used for printing the numeric values
in each cell in the current column. Enter two numbers: the
total width in characters of the column, and the number of dig‐
its to follow decimal points. Values are rounded off to the
least significant digit displayed. The total column width
affects displays of strings as well as numbers. A preceding
count can be used to affect more than one column. This command
has only a column version (no second letter).
Range Commands
Range operations affect a rectangular region on the screen defined by
the upper left and lower right cells in the region. All of the com‐
mands in this class start with a slash; the second letter of the com‐
mand indicates which command. A small menu lists the choices for the
second letter when you type ``/''. sc prompts for needed parameters
for each command. Phrases surrounded by square brackets in the prompt
are informational only and may be erased with the backspace key.
Prompts requesting variable names may be satisfied with either an
explicit variable name, such as A10, or with a variable name previously
defined in a /d command (see below). Range name prompts require either
an explicit range such as A10:B20, or a range name previously defined
with a /d command. A default range shown in the second line is used if
you omit the range from the command or press the TAB key (see below).
The default range can be changed by moving the cell cursor via the con‐
trol commands (^P, ^N, ^B, ^F) or the arrow keys. The cells in the
default range are highlighted (using the terminal's standout mode, if
available).
/x Clear a range. Cells cleared with this command may be recalled
with any of the pull commands.
/v Values only. This command removes the expressions from a range
of cells, leaving just the values of the expressions.
/c Copy a source range to a destination range. The source and des‐
tination may be different sizes. The result is always one or
more full copies of the source. Copying a row to a row yields a
row. Copying a column to a column yields a column. Copying a
range to anything yields a range. Copying a row to a column or
a column to a row yields a range with as many copies of the
source as there are cells in the destination. This command can
be used to duplicate a cell through an arbitrary range by making
the source a single cell range such as b20:b20.
/f Fill a range with constant values starting with a given value
and increasing by a given increment. Each row is filled before
moving on to the next row if row order recalculation is set.
Column order fills each column in the range before moving on to
the next column. The start and increment numbers may be posi‐
tive or negative. To fill all cells with the same value, give
an increment of zero.
/d Use this command to assign a symbolic name to a single cell or a
rectangular range of cells on the screen. The parameters are
the name, surrounded by "", and either a single cell name such
as A10 or a range such as a1:b20. Names defined in this fashion
are used by the program in future prompts, may be entered in
response to prompts requesting a cell or range name, and are
saved when the spreadsheet is saved with the Put command. Names
defined must be more than two alpha characters long to differen‐
tiate them from a column names, and must not have embedded spe‐
cial characters. Names may include the character ``_'' or
numerals as long as they occur after the first three alpha char‐
acters.
/s This command lists (shows) the currently defined range names.
If there are no defined range names, then a message is given,
otherwise it pipes output to sort, then to less. If the envi‐
ronment variable PAGER is set, its value is used in place of
less.
/u Use this command to undefine a previously defined range name.
Miscellaneous Commands
Q
q
^C Exit from sc. If you made any changes since the last Get or
Put, sc asks about saving your data before exiting.
^G
ESC Abort entry of the current command.
? Enter an interactive help facility. Lets you look up brief sum‐
maries of the main features of the program. The help facility
is structured like this manual page so it is easy to find more
information on a particular topic.
! Shell escape. sc prompts for a shell command to run. End the
command line with the RETURN key. If the environment variable
SHELL is defined, that shell is run. If not, /bin/sh is used.
Giving a null command line starts the shell in interactive mode.
A second ``!'' repeats the previous command.
^L Redraw the screen.
^R Redraw the screen with special highlighting of cells to be
filled in. This is useful for finding values you need to pro‐
vide or update in a form with which you aren't familiar or of
which you have forgotten the details.
It's also useful for checking a form you are creating. All
cells which contain constant numeric values (not the result of a
numeric expression) are highlighted temporarily, until the next
screen change, however minor. To avoid ambiguity, the current
range (if any) and current cell are not highlighted.
^X This command is similar to ^R, but highlights cells which have
expressions. It also displays the expressions in the high‐
lighted cells as left-flushed strings, instead of the numeric
values and/or label strings of those cells. This command makes
it easier to check expressions, at least when they fit in their
cells or the following cell(s) are blank so the expressions can
slop over (like label strings). In the latter case, the slop
over is not cleared on the next screen update, so you may want
to type ^L after the ^X in order to clean up the screen.
@ Recalculates the spreadsheet.
^V Type, in the command line, the name of the current cell (the one
at the cell cursor). This is useful when entering expressions
which refer to other cells in the table.
^W Type, in the command line, the expression attached to the cur‐
rent cell. If there is none, the result is ``?''.
^A Type, in the command line, the numeric value of the current
cell, if any.
The ^V, ^W, and ^A commands only work when the character cursor is on
the command line and beyond the first character.
TAB When the character cursor is on the top line, defines a range of
cells via the cursor control commands or the arrow keys. The
range is highlighted, starts at the cell where you typed TAB,
and continues through the current cell cursor. Pressing TAB
again causes the highlighted range to be entered into the com‐
mand line and the highlighting to be turned off. This is most
useful for defining ranges to functions such as @sum(). Press‐
ing ``)'' acts just like typing the TAB key the second time and
adds the closing ``)''. Note that when you give a range com‐
mand, you don't need to press the first TAB to begin defining a
range starting with the current cell.
Variable Names
Normally, a variable name is just the name of a cell, such as K20. The
value is the numeric or string value of the cell, according to context.
When a cell's expression (formula) is copied to another location via
copy or range-copy, variable references are by default offset by the
amount the formula moved. This allows the new formula to work on new
data. If cell references are not to change, you can either use the
fixed operator (see below), or one of the following variations on the
cell name.
K20 References cell K20; the reference changes when the formula is
copied.
$K$20 Always refers to cell K20; the reference stays fixed when the
formula is copied.
$K20 Keeps the column fixed at column K; the row is free to vary.
K$20 Similarly, this fixes the row and allows the column to vary.
These conventions also hold on defined ranges. Range references vary
when formulas containing them are copied. If the range is defined with
fixed variable references, the references do not change.
fixed To make a variable not change automatically when a cell moves,
put the word fixed in front of the reference, for example: B1 ∗
fixed C3.
Numeric Expressions
Numeric expressions used with the ``='' and e commands have a fairly
conventional syntax. Terms may be constants, variable names, parenthe‐
sized expressions, and negated terms. Ranges may be operated upon with
range functions such as sum (@sum()) and average (@avg()). Terms may
be combined using binary operators.
-e Negation.
e+e Addition.
e-e Subtraction.
e∗e Multiplication.
e/e Division.
e1%e2 e1 mod e2.
e^e Exponentiation.
e<e
e<=e
e=e
e!=e
e>=e
e>e Relationals: true (1) if and only if the indicated relation
holds, else false (0). Note that ``<='', ``!='', and ``>='' are
converted to their ``~()'' equivalents.
~e Boolean operator NOT.
e&e Boolean operator AND.
e|e Boolean operator OR.
@if(e,e,e)
e?e:e Conditional: If the first expression is true then the value of
the second is returned, otherwise the value of the third.
Operator precedence from highest to lowest is:
-, ~
^
∗, /
+, -
<, <=, =, !=, >=, >
&
|
?:
Built-in Range Functions
These functions return numeric values.
@sum(r) Sum all valid (nonblank) entries in the region whose
two corners are defined by the two variable names
(e.g. c5:e14) or the range name specified.
@prod(r) Multiply together all valid (nonblank) entries in the
specified region.
@avg(r) Average all valid (nonblank) entries in the specified
region.
@count(r) Count all valid (nonblank) entries in the specified
region.
@max(r) Return the maximum value in the specified region.
See also the multi argument version of @max below.
@min(r) Return the minimum value in the specified region.
See also the multi argument version of @min below.
@stddev(r) Return the sample standard deviation of the cells in
the specified region.
@lookup(e,r)
@lookup(se,r) Evaluates the expression then searches through the
range r for a matching value. The range should be
either a single row or a single column. The expres‐
sion can be either a string expression or a numeric
expression. If it is a numeric expression, the range
is searched for the the last value less than or equal
to e. If the expression is a string expression, the
string portions of the cells in the range are
searched for an exact string match. The value
returned is the numeric value from the next row and
the same column as the match, if the range was a sin‐
gle row, or the value from the next column and the
same row as the match if the range was a single col‐
umn.
@hlookup(e,r,n)
@hlookup(se,r,n) Evaluates the expression then searches through the
first row in the range r for a matching value. The
expression can be either a string expression or a
numeric expression. If it is a numeric expression,
the row is searched for the the last value less than
or equal to e. If the expression is a string expres‐
sion, the string portions of the cells in the row are
searched for an exact string match. The value
returned is the numeric value from the same column n
rows below the match.
@vlookup(e,r,n)
@vlookup(se,r,n) Evaluates the expression then searches through the
first column in the range r for a matching value.
The expression can be either a string expression or a
numeric expression. If it is a numeric expression,
the column is searched for the the last value less
than or equal to e. If the expression is a string
expression, the string portions of the cells in the
column are searched for an exact string match. The
value returned is the numeric value from the same row
n columns to the right of the match.
@index(e,r) Use the value of the expression e to index into the
range r. The numeric value at that position is
returned. The value 1 selects the first item in the
range, 2 selects the second item, etc. R should be
either a single row or a single column.
@stindex(e,r) Use the value of e to index into the range r. The
string value at that position is returned. The value
1 selects the first item in the range, 2 selects the
second item, etc. The range should be either a sin‐
gle row or a single column.
Built-in Numeric Functions
All of these functions operate on floating point numbers (doubles) and
return numeric values. Most of them are standard system functions more
fully described in math(3). The trig functions operate with angles in
radians.
@sqrt(e) Return the square root of e.
@exp(e) Return the exponential function of e.
@ln(e) Return the natural logarithm of e.
@log(e) Return the base 10 logarithm of e.
@floor(e) Return the largest integer not greater than e.
@ceil(e) Return the smallest integer not less than e.
@rnd(e) Round e to the nearest integer.
@round(e,n) Round e to n decimal places.
@abs(e)
@fabs(e) Return the absolute value of e.
@pow(e1,e2) Return e1 raised to the power of e2.
@hypot(e1,e2) Return sqrt(e1∗e1+e2∗e2), taking precautions against
unwarranted overflows.
pi A constant quite close to pi.
@dtr(e) Convert e in degrees to radians.
@rtd(e) Convert e in radians to degrees.
@sin(e)
@cos(e)
@tan(e) Return trigonometric functions of radian arguments.
The magnitude of the arguments are not checked to
assure meaningful results.
@asin(e) Return the arc sine of e in the range -pi/2 to pi/2.
@acos(e) Return the arc cosine of e in the range 0 to pi.
@atan(e) Return the arc tangent of e in the range -pi/2 to
pi/2.
@atan2(e1,e2) Returns the arc tangent of e1/e2 in the range -pi to
pi.
@max(e1,e2,...) Return the maximum of the values of the expressions.
Two or more expressions may be specified. See also
the range version of @max above.
@min(e1,e2,...) Return the minimum of the values of the expressions.
Two or more expressions may be specified. See also
the range version of @min above.
@ston(se) Convert string expression se to a numeric value.
@eqs(se1,se2) Return 1 if string expression se1 has the same value
as string expression se2, 0 otherwise.
@nval(se,e) Return the numeric value of a cell selected by name.
String expression se must evaluate to a column name
(``A''-``AE'') and e must evaluate to a row number
(0-199). If se or e is out of bounds, or the cell
has no numeric value, the result is 0. You can use
this for simple table lookups. Be sure the table
doesn't move unexpectedly! See also @sval() below.
String Expressions
String expressions are made up of constant strings (characters sur‐
rounded by double quotation marks), variables (cell names, which refer
to the cells's label strings or expressions), and string functions.
Note that string expressions are only allowed when entering a cell's
label string, not its numeric part. Also note that string expression
results may be left or right flushed, according to the type of the
cell's string label.
# Concatenate strings. For example, the string expression
A0 # "zy dog"
displays the string ``the lazy dog'' in the cell if the value of
A0's string is ``the la''.
Built-in String Functions
@substr(se,e1,e2) Extract and return from string expression se the sub‐
string indexed by character number e1 through charac‐
ter number e2 (defaults to the size of se if beyond
the end of it). If e1 is less than 1 or greater than
e2, the result is the null string. For example,
@substr ("Nice jacket", 4, 7)
returns the string ``e jac''.
@fmt(se,e) Convert a number to a string. The argument se must
be a valid printf(3) format string. e is converted
according to the standard rules. For example, the
expression
@fmt ("∗∗%6.3f∗∗", 10.5)
yields the string ``∗∗10.500∗∗''. e is a double, so
applicable formats are e, E, f, g, and G. Try ``%g''
as a starting point.
@sval(se,e) Return the string value of a cell selected by name.
String expression se must evaluate to a column name
(``A''-``AE'') and e must evaluate to a row number
(0-199). If se or e is out of bounds, or the cell
has no string value, the result is the null string.
You can use this for simple table lookups. Be sure
the table doesn't move unexpectedly!
@ext(se,e) Call an external function (program or script). The
purpose is to allow arbitrary functions on values,
e.g. table lookups and interpolations. String
expression se is a command or command line to call
with popen(3). The value of e is converted to a
string and appended to the command line as an argu‐
ment. The result of @ext() is a string: the first
line printed to standard output by the command. The
command should emit exactly one output line. Addi‐
tional output, or output to standard error, messes up
the screen. @ext() returns a null string and prints
an appropriate warning if external functions are dis‐
abled, se is null, or the attempt to run the command
fails.
External functions can be slow to run, and if enabled
are called at each screen update, so they are dis‐
abled by default. You can enable them with ^T when
you really want them called.
A simple example:
@ext ("echo", a1)
You can use @ston() to convert the @ext() result back
to a number. For example:
@ston (@ext ("form.sc.ext", a9 + b9))
Note that you can built a command line (including
more argument values) from a string expression with
concatenation. You can also "hide" the second argu‐
ment by ending the command line (first argument) with
`` #'' (shell comment).
Built-in Financial Functions
Financial functions compute the mortgage (or loan) payment, future
value, and the present value functions. Each accepts three arguments,
an amount, a rate of interest (per period), and the number of periods.
These functions are the same as those commonly found in other spread‐
sheets and financial calculators
@pmt(e1,e2,e3) @pmt(60000,.01,360) computes the monthly payments for
a $60000 mortgage at 12% annual interest (.01 per
month) for 30 years (360 months).
@fv(e1,e2,e3) @fv(100,.005,36) computes the future value for of 36
monthly payments of $100 at 6% interest (.005 per
month). It answers the question: "How much will I
have in 36 months if I deposit $100 per month in a
savings account paying 6% interest compounded
monthly?"
@pv(e1,e2,e3) @pv(1000,.015,36) computes the present value of an a
ordinary annuity of 36 monthly payments of $1000 at
18% annual interest. It answers the question: "How
much can I borrow at 18% for 30 years if I pay $1000
per month?"
Built-in Date and Time Functions
Time for sc follows the system standard: the number of seconds since
1970. All date and time functions except @date() return numbers, not
strings.
@now Return the current time encoded as the number of sec‐
onds since the beginning of the epoch (December 31,
1969, midnight, GMT.)
@dts(e1,e2,e3) @dts(9,14,1988) converts the date September 14, 1988
to the number of seconds from the epoch to the first
second of 9/14/88, local time. For example,
@date(@dts(12,14,1976)) yields
Tue Dec 14 00:00:00 1976
The month should be range from 1 to 12, the day
should range from 1 to the number of days in the
specified month, and the year should range from 1970
to 1999.
@tts(e1,e2,e3) @tts(8,20,45) converts the time 8:40:45 to the number
of seconds since midnight, the night before. The
hour should range from 0 to 23; the minutes and sec‐
onds should range from 0 to 59.
The following functions take the time in seconds (e.g. from @now) as an
argument and return the specified value. The functions all convert
from GMT to local time.
@date(e) Convert the time in seconds to a date string 24 char‐
acters long in the following form:
Sun Sep 16 01:03:52 1973
Note that you can extract parts of this fixed-format
string with @substr().
@year(e) Return the year. Valid years begin with 1970. The
last legal year is system dependent.
@month(e) Return the month, encoded as 1 (January) to 12
(December).
@day(e) Return the day of the month, encoded as 1 to 31.
@hour(e) Return the number of hours since midnight, encoded as
0 to 23.
@minute(e) Return the number of minutes since the last full
hour, encoded as 0 to 59.
@second(e) Return the number of seconds since the last full
minute, encoded as 0 to 59.
Spreadsheet Update
Re-evaluation of spreadsheet expressions is done by row or by column
depending on the selected calculation order. Evaluation is repeated up
to iterations times for each update if necessary, so forward references
usually work as expected. See set above. If stability is not reached
after ten iterations, a warning is printed. This is usually due to a
long series of forward references, or to unstable cyclic references
(for example, set A0's expression to ``A0+1'').
SEE ALSObc(1), dc(1), crypt(1)BUGS
Top-to-bottom, left-to-right evaluation of expressions is silly. A
proper following of the dependency graph with (perhaps) recourse to
relaxation should be implemented.
Editing is crude. All you can do is backspace over and retype text to
be altered. There is no easy way to switch a leftstring to a right‐
string or vice versa. Of course, you can always write the spreadsheet
to a file with Put, edit it by calling an editor on the file with
``!'', and read it back with Get -- if you are comfortable editing
spreadsheet files.
Only one previous value is saved from any call of @ext(). If it is
used more than once in a spreadsheet and external functions are enabled
and later disabled, the last returned value pops up in several places.
On some systems, if the cell cursor is in column 0 with topline enabled
(so the current cell is highlighted), or if any cell in column 0 is
highlighted, the corresponding row number gets displayed and then
blanked during a screen refresh. This looks like a bug in curses.
Many commands give no indication (a message or beep) if they have null
effect. Some should give confirmation of their action, but they don't.
SC(1)