SC 6.21 (1) UNIX System V SC 6.21 (1)
NAME
sc - spreadsheet calculator
SYNOPSIS
sc [ -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.
For a on-line tutorial, type the command:
sc /usr/freeware/lib/sc/tutorial.sc
To print a quick reference card, type the command:
scqref | [your_printer_commmand]
OPTIONS
-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.
-R Start the program with automatic newline action set to
increment the row (see below).
-C Start the program with automatic newline action set to
increment the column (see below).
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 override options saved in the data file.
Page 1 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
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 table. 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
recalculated. Normally this is not noticeable,
but for very large spreadsheets, it may be faster
Page 2 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
to clear automatic recalculation mode and update
the spreadsheet via explicit ``@'' commands.
Default is automatic recalculation 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 cursor.
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 functions 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.
l Autolabeling. If enabled, using the define
command (/d) causes a label to be automatically
generated in the cell to the left of the defined
cell. This is only done if the cell to the left
is empty. Default is enabled.
n Quick numeric entry. If enabled, a typed digit is
assumed to be the start of a numeric value for the
current cell, not a repeat count, unless preceded
by ^U. The cursor controls (^P, ^N, ^B, ^F) in
this mode will end a numeric entry.
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
centered string, ``<'' for a leftstring or ``>''
for a rightstring (see below), followed by
"string" for a constant string or {expr} for a
string expression. A constant string may be
preceeded with a backslash (`\'). In this case
the constant string will be used as a ``wheel'' to
fill a column, e.g. "\-" for a line in a column,
and "\Yeh " for "Yeh Yeh Ye". 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
Page 3 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
figures.
r Newline action. This option toggles between three
cases. The default is no action. If this option
is used once, after each command which is
terminated by a newline character is completed,
the current cell will be moved down one row. If
this option is used again, after each command
which is terminated by a newline character is
completed, the current cell will be moved right
one column. Another use of this option will
restore the default action.
z Set newline action limits. This option sets
limits to the newline action option above. When
this option is invoked, the row and column of the
current cell are remembered. If a later newline
action would take the current cell to the right of
the remembered column, then the current cell is
instead moved to the first column of the next row.
If a newline action would take the current cell
below the remembered row, then the current cell is
instead moved to the top row of the next column.
The quick numeric entry, newline action and set newline
action limits options can be combined to allow very
quick entry of large amounts of data. If all the data
to be entered is in a single row or column then setting
the quick numeric entry and the appropriate newline
action will allow the numbers to be entered without any
explicit commands to position the current cell or enter
a number.
If the data entry involves several entries in each row
for many rows, then setting the quick numeric entry
option, setting the newline action to move right after
each entry and setting the newline action limits on the
last column on which data should be entered will allow
the data to entered quickly. If necessary, columns
which do not need data to be entered can be hidden with
the z command. Similar arrangements can be made for
entering several rows of data in each column.
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.
Page 4 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
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 environment; slatex to give a SLaTeX
(Scandinavian LaTeX) tabular environment; tex to
give a TeX simple tabbed alignment with ampersands
as delimiters; and frame to give a tblstyle output
for FrameMaker.
Other Set options are normally used only in sc data
files since they are available through ^T. You can
also use them interactively
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.
rndinfinity/!rndinfinity
default: round-to-even (banker's round), *.5 will
round to the closest even number; doing a 'set
rndinfinity' will round *.5 up to the next integer
(rounding to infinity).
craction=n
Set the newline action. n can be: 0 (default) to
give no action; 1 to move down after each entry;
or 2 to move right after each entry.
rowlimit=n
Set the remembered limit for the maximum row below
which the current cell will be moved to the top of
Page 5 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
the next column if the newline action is set to
move the current cell down. n can be -1 (default)
to disable this facility.
collimit=n
Set the remembered limit for the maximum column to
the right of which the current cell will be moved
to the left of the next row if the newline action
is set to move the current cell right. n can be
-1 (default) to disable this facility.
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 alternate, vi-compatible cell cursor controls
(left, down, up, right). Space is just like l (right).
H, J, K, L
If the character cursor is not on the top line, these
move the cursor by half pages (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 appropriate termcap entry. Some terminals have
arrow keys which conflict 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.
Page 6 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
# 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 command
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
expression 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 expression 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. You may also go to a
cell with an ERROR (divide by zero, etc in this cell)
or INVALID (references a cell containing an ERROR).
g error will take you to the next ERROR, while
g invalid take you to the next invalid. 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
Page 7 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
alters the cell's previous numeric value, if any, and
replaces the cell's previous string expression, if any,
leaving 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 number in response to the prompt
on the top line. The quick numeric entry option,
enabled through the -n option or ^T command, shows the
prompt when you enter the first digit of a number (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
centered in the column.
> Enter a label string into the current cell to be
flushed right against the right edge of the cell.
F Enter a format string into the current cell. This
format string overrides the precision specified with
the ``f'' command. The format only applies to numeric
values. The following characters can be used to build
a format string:
# Digit placeholder. If the number has fewer digits
on either side of the decimal point than there
are `#' characters in the format, the extra `#'
characters are ignored. The number is rounded to
the number of digit placeholders as there are to
the right of the decimal point. If there are more
digits in the number than there are digit
placeholders on the left side of the decimal
point, then those digits are displayed.
0 Digit placeholder. Same as for `#' except that
the number is padded with zeroes on either side of
the decimal point. The number of zeroes used in
padding is determined by the number of digit
placeholders after the `0' for digits on the left
side of the decimal point and by the number of
digit placeholders before the `0' for digits on
the right side of the decimal point.
. Decimal point. Determines how many digits are
Page 8 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
placed on the right and left sides of the decimal
point in the number. Note that numbers smaller
than 1 will begin with a decimal point if the left
side of the decimal point contains only a `#'
digit placeholder. Use a `0' placeholder to get a
leading zero in decimal formats.
% Percentage. For each `%' character in the format,
the actual number gets multiplied by 100 (only for
purposes of formatting -- the original number is
left unmodified) and the `%' character is placed
in the same position as it is in the format.
, Thousands separator. The presence of a `,' in the
format (multiple commas are treated as one) will
cause the number to be formatted with a `,'
separating each set of three digits in the integer
part of the number with numbering beginning from
the right end of the integer.
\ Quote. This character causes the next character
to be inserted into the formatted string directly
with no special interpretation.
E- E+ e- e+
Scientific format. Causes the number to formatted
in scientific notation. The case of the `E' or
`e' given is preserved. If the format uses a `+',
then the sign is always given for the exponent
value. If the format uses a `-', then the sign is
only given when the exponent value is negative.
Note that if there is no digit placeholder
following the `+' or `-', then that part of the
formatted number is left out. In general, there
should be one or more digit placeholders after the
`+' or `-'.
; Format selector. Use this character to separate
the format into two distinct formats. The format
to the left of the `;' character will be used if
the number given is zero or positive. The format
to the right of the `;' character is used if the
number given is negative.
Some example formats are integer (``0'' or ``#''),
fixed (``0.00''), percentage (``0%'' or ``0.00%''),
scientific (``0.00E+00''), and currency
(``$#,0.00;($#,0.00)'').
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
Page 9 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
prompt.
e Edit the value associated with the current cell. This
is identical to ``='' except that the command line
starts out containing the old numeric value or
expression associated with the cell. The editing in
this mode is vi-like.
^h Move back a character
+ Forward through history (neat) (same as j)
- Backward through history (neat) (same as k)
ESC Done editing
TAB Mark && append a range (ex: A0:A0)
TAB, move around within a range; TAB, append range
string.
CR Save
$ Goto last column
. Insert current dot buffer
/ Search for a string in the history
ESC edit the string you typed
CR search
^h backspace
0 Goto column 0
D Delete to send
I Insert at column 0; ESC revert back to edit mode
R Replace mode; ESC revert back to edit mode
X Delete the char to the left
a Append after cursor; ESC revert back to edit mode
b Move back a word
c Change mode; ESC revert back to edit mode
d Delete ...
b back word
f forward (right)
h back char
l forward
Page 10 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
t delete forward up to a given char (next char
typed)
w delete next word forward
f Find the next char typed
h Move left a char
i Insert before cursor; ESC revert back to edit mode
j Forward through history (neat) (same as +)
k Backward through history (neat) (same as -)
l Move right a char
n Continue search
q Stop editing
r Replace char
t Goto a char
u Undo
w Forward a word
x Delete the current char (moving to the right)
E Edit the string associated with the current cell. This
is identical to ``<'', ``"'', or ``>'' except that the
command line starts out containing the old string value
or expression associated with the cell. SEE e ABOVE.
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 expressions 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 recalculation 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
Page 11 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
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 ``=''.
RETURN
If you are not editing a cell (top line is empty),
pressing RETURN will make sc enter insert mode. At this
point you may type any valid command or press ESC once
to edit.
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 table processors. The delimiters are
controlled by the tblstyle option. See Set above. The
delimiters are are a colon (:) for style 0 or tbl and
an ampersand (&) for style latex or tex.
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 (potentially) dangerous operation
is really what you want.
Page 12 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
The three output commands, Put, Write, and Table, can pipe
their (unencrypted only) output to a program. To use this
feature, enter ``| program'' 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
database. 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 possible 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 filename. 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
interpreted as a UNIX command, as above.
Row and Column Commands
These commands can be used on either rows or columns. The
second letter 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
Page 13 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
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 (column) 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 three numbers: the total width in characters of
the column, the number of digits to follow decimal
points, and the format type. Format types are 0 for
fixed point, 1 for scientific notation, 2 for
engineering notation, and 3 for dates. 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).
@myrow, @mycol
Are functions that return the row or column of the
current cell respectively. ex: The cell directly above
a cell in the D column could then be accessed by
Page 14 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
@nval("d",@myrow-1). NOTE: @myrow and @mycol can't be
used in specifying ranges.
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 commands in this class start with a
slash; the second letter of the command 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 control 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 destination 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 positive or
Page 15 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
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 differentiate them from a column
names, and must not have embedded special characters.
Names may include the character ``_'' or numerals as
long as they occur after the first three alpha
characters.
/l Use this command to lock the current cell or a range of
cells, i.e make them immune to any type of editing. A
locked cell can't be changed in anyway until it is
unlocked.
/U This command is the opposite of the /l command and thus
unlocks a locked cell and makes it editable.
/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 environment variable PAGER is
set, its value is used in place of less.
/u Use this command to undefine a previously defined range
name.
/F Use this command to assign a value format string (see
the ``F'' cell entry command) to a range of cells.
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 summaries of the main features of the program.
The help facility is structured like this manual page
Page 16 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
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 provide 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 highlighted 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 current 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
Page 17 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
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 command line
and the highlighting to be turned off. This is most
useful for defining ranges to functions such as @sum().
Pressing ``)'' acts just like typing the TAB key the
second time and adds the closing ``)''. Note that when
you give a range command, 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.
Page 18 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
Numeric Expressions
Numeric expressions used with the ``='' and e commands have
a fairly conventional syntax. Terms may be constants,
variable names, parenthesized 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:
-, ~
^
*, /
+, -
<, <=, =, !=, >=, >
&
|
Page 19 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
?:
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 expression 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
single row, or the value from the next
column and the same row as the match if
the range was a single column.
@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 expression,
the string portions of the cells in the
row are searched for an exact string
match. The value returned is the numeric
Page 20 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
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
single 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.
Page 21 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
@rnd(e) Round e to the nearest integer. default:
round-to-even (banker's round), *.5 will
round to the closest even number; 'set
rndinfinity' will round *.5 up to the next
integer.
@round(e,n) Round e to n decimal places. n may be
positive to round off the right side of
the decimal, and negative to round off the
left side. See @rnd(e) above for rounding
types.
@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 @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.
Page 22 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
@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 surrounded 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 or centered,
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 substring indexed by character
number e1 through character 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
Page 23 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
@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!
@upper(e) and @lower(e) will case the string
expression to upper or lower.
@capital(e) will convert the first letter of words in
a string into upper case and other letters
to lower case (the latter if all letters
of the string are upper case).
@upper(e) and @lower(e) will case the string
expression to upper or lower.
@capital(e) will convert the first letter of words in
a string into upper case.
@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 argument. 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. Additional output, or output to
standard error, messes up the screen.
@ext() returns a null string and prints an
appropriate warning if external functions
are disabled, 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 disabled by default.
You can enable them with ^T when you
Page 24 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
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 argument by
ending the command line (first argument)
with `` #'' (shell comment).
@coltoa(e) Returns a string name for a column from
the numeric argument. For example:
@coltoa(@mycol-1)
@nval(coltoa(@mycol-1), @myrow+1)
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 spreadsheets 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
Page 25 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
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 seconds 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 seconds 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 characters 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
Page 26 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (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'').
@numiter Returns the number of iterations performed
so far.
FILES
/usr/freeware/lib/sc/tutorial.sc tutorial spreadsheet
SEE ALSO
bc(1), dc(1), crypt(1), psc(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.
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.
AUTHORS
Page 27 (printed 1/13/100)
SC 6.21 (1) UNIX System V SC 6.21 (1)
This is a much modified version of a public domain spread
sheet originally authored by James Gosling, and subsequently
modified and posted to USENET by Mark Weiser under the name
vc. The program was subsequently renamed sc, and further
modified by numerous contributors, Jeff Buhrt of Proslink,
Inc. ({sequent, uunet}!sawmill!prslnk!buhrt) and Robert
Bond of Sequent, prominent among them. Other contributors
include: Tom Anderson, Glenn T. Barry, Gregory Bond,
Stephen (Steve) M. Brooks, Peter Brower, John Campbell,
Lawrence Cipriani, Jim Clausing, Dave Close, Chris Cole,
Jonathan Crompron, David I. Dalva, Glen Ditchfield, Sam
Drake, James P. Dugal, Paul Eggert, Andy Fyfe, Jack Goral,
Piercarlo "Peter" Grandi, Henk Hesselink, Jeffrey C Honig,
Kurt Horton, Jonathan I. Kamens, Peter King, Tom Kloos,
Casey Leedom, Jay Lepreau, Dave Lewis, Rick Linck, Soren
Lundsgaard, Tad Mannes, Rob McMahon, Chris Metcalf, Mark
Nagel, Ulf Noren, Marius Olafsson, Gene H. Olson, Henk P.
Penning, Rick Perry, Larry Philps, Eric Putz, Jim
Richardson, Michael Richardson, R. P. C. Rodgers, Kim
Sanders, Mike Schwartz, Alan Silverstein, Lowell Skoog, Herr
Soeryantono, Tim Theisen, Tom Tkacik, Andy Valencia, Adri
Verhoef, Rick Walker, Petri Wessman, and Tim Wilson.
Page 28 (printed 1/13/100)
