xspread, sc

Tabellenkalkulation (Spreadsheet)
für xspread: X11
xspread [mysheet.sc] &
sc [mysheet.sc]
Online-Hilfe mittels "?", scqref
man xspread, man sc, man psc
Xspread Reference Manual
Demo, Tutorial:
ASCII-Tabellen können mittels psc in SC-Tabellen umgewandelt werden:
psc < input.txt > output.sc


This is a brief sc tutorial, best run in a 24-line window. Type 'q' to exit, ^Z to suspend (w/ Job Control). ^G interrupts a command.

Cells are named by their column and row number. For example,

Cell A6   Cell B6   Cell C6
Cell A7
Cell A8             Cell C8

Cells range from A0 to ZZ(some number depending on free memory). Cells can also be named by the user. See 'range names' in the manual. You can move the cursor a couple of different ways:

          ^n, j and the <DOWN> arrow key go down
          ^p, k and the <UP> arrow key go up
          ^b, h and the <LEFT> arrow key go left
          ^f, l and the <RIGHT> arrow key go right

You can go directly to a cell by typing 'g' and the cell name

          'g c6' will take you to cell c6.

Cells can contain numbers, formulas, or text. Most of the cells on this page contain text.

Cell d23 contains text        Text
Cell d24 contains a number        123.34
Cell d25 contains a formula       211.34

To see what the cell contains, just move the cursor onto the cell. The contents will show up on line 1 in the brackets.

You can enter data into cells like this:

          '<text' enters left justified text.
          '>text' enters right justified text.
          '=number' enters a number
          '=formula' enters a formula.
Try duplicating d23 through d25 in e23 though e25. You erase a cell by typing 'x' with the cursor on the cell. Here is a typical use for numbers and formulas:

     10.30   1877.50    234.70             2122.50
     44.56     44.30     -3.00               85.86
     88.74   8000.00     -9.00             8079.74
     99.20    -88.00    -44.60              -33.40

    242.80   9833.80    178.10            10254.70
The data is entered in a45 through c48.
Cells a50, b50 and c50 sum their respective columns.
Cells e45, e46, e47, and e48 sum their respective rows.
Cell E50 is a grand total.
Try changing some of the data cells and watch the sums change.
You can also edit cells by putting the cursor on the cell and typing:

          'e' to edit the numeric portion.
          'E' to edit the string portion.

Since you are reading this, you know that you can load a data base from a file by typing the file name as an argument to the program. You can also load or save a data base using the file commands:

          'G file'  Gets the data from an sc file.
          'P file'  Puts the data from the spreadsheet
                    into a file.
Try 'P foo.sc' to write this to the file foo.sc The Get command erases the current spreadsheet. To merge a spreadsheet with the one currently in the machine, use:

          'M file'  Merge the data from a saved sc file.
You can also get human readable versions of the data by using the Write command:

Try 'W tut.txt' for a clear text version of the tutorial.

This is the end of the tutorial. We have explored The basic commands. Much more detail is available in the man page.

To quit this program, type 'q'.

Quick Reference


B: Toggle Options

^To Toggle options. Toggle one option selected by o:

  a    Recalculate automatically or on ``@'' commands.
  c    Current cell highlighting enable/disable.
  e    External function execution enable/disable.
  l    Autolabeling defined cells enable/disable.
  n    If enabled, a digit starts a numeric value.
  t    Top line display enable/disable.
  x    Encrypt/decrypt database and listing files (Not available).
  $    Dollar prescale.  If enabled, all numeric constants
       (not expressions) entered are multipled by 0.01.
  r    Newline action.  Toggle between no action, move down
       after entry and move right after entry.
  z    Set the newline action limits to the current row and column
    (for r && z see also set rowlimit=n, collimit=n)

C: Set Options

S Set options. Options include:

  byrows        Recalculate in row order. (default)
  bycols        Recalculate in column order.
  iterations=n  Set the number of iterations allowed. (10)
  tblstyle=xx   Set ``T'' output style to:
                0 (none), tex, latex, slatex, or tbl.
  rndinfinity   Round to infinity (round .5 up vs to nearest even).
  rowlimit=n    Set the remembered row limit for newline action.
  collimit=n    Set the remembered column limit for newline action.
             (rowlimit and collimit can both be set by ^Tz)

D: Cell cursor movement (always OK)

 ^N ^P ^B ^F    Down, up, back, forward
 ^Ed            Go to end of range. Follow ^E by a direction
                indicator such as ^P or j.
 Arrow keys     (if the terminal and termcap support them.)

Cell cursor movement if no prompt active:

 j,k,l,h  Down, up, right, left
 J,K,L,H  Down, up, right, left by 1/2 pages
 SPACE    Forward
 ^H       Back
 TAB      Forward, otherwise starts/ends a range
 ^        Up to row 0 of the current column.
 #        Down to the last valid row of the current column.
 0        Back to column A. Preface with ^U if numeric mode.
 $        Forward to the last valid column of the current row.
 b        Back then up to the previous valid cell.
 w        Forward then down to the next valid cell.
 g        Go to a cell.  Cell name, range name, quoted string,
          a number, 'error', or 'invalid' to specify which cell.

E: Cell entry and editing commands

 =        Enter a numeric constant or expression.
 <        Enter a left justified string or string expression.
 "        Enter a centered label.
 >        Enter a right justified string or string expression.
 e        Edit the current cell's numeric value.
 E        Edit the current cell's string part.
 F        Assign a format to the current cell's numeric value.
 x        Clear the current cell.
 c        Copy the last marked cell to the current cell.
 m        Mark a cell to be used as the source for ``c''
 +        Increment numeric part
 -        Decrement numeric part
  RETURN  Enter insert mode if the input line was empty (ESC to edit)

In numeric mode, a decimal digit, ``+'', ``-'', and ``.'' all start a new numeric constant or expression.

F: Line Editor

Hitting the ESC key while entering any command on the top line will start a one-line vi-style editor. Supported commands:

 ESC q    Abort command entry.
 h l      Move cursor forward, backward.
 0 $      Move cursor to the beginning, end of the line.
 b w      Move cursor forward/back one word.
 fc       Move cursor to character c.
 tc       Move the cursor the the character before c.
 i a      Enter insert mode before/after the cursor.
 I A      Move to column 0/end of line and enter insert mode.
 x X      Delete the character under/before the cursor.
 rc       Replace the character under the cursor with c.
 cm       Change - m = b,f,h,l,t or w.
 dm       Delete - m = b,f,h,l,t or w.
 R        Enter replace (overstrike) mode.
 + j - k /  Forward/backward/search the command history.
 n        Repeat last history search.
 . u      Repeat/undo the last command.

G: File commands

 G        Get a new database from a file.
 M        Merge a new file into the current database.
 P        Put the current database into a file.
 W        Write a listing of the current database into a file in
          a form that matches its appearance on the screen.
 T        Write a listing of the current database to a file, but
          put delimiters between each pair of fields.
          Optionally brackets output with control lines for ``tbl'',
          ``LaTeX'', ``SLaTex'', or ``TeX''.

``"| program"'' for a file name will pipe output to a program for Put, Write and Table. If a cell name is used as the file name, the cell's string part will be used as the file name.

H: Row and column commands

 ir, ic         Insert a new, empty row (column)
 ar, ac         Append a new copy of the current row (column)
 dr, dc         Delete the current row (column)
 pr, pc, pm     Pull deleted cells back into the spreadsheet
                Insert rows, columns or merge the cells.
 vr, vc         Remove expressions from the affected rows (columns),
                leaving only the values.
 zr, zc         Hide (``zap'') the current row (column)
 sr, sc         Show hidden rows (columns)
 f              Set the output format to be used with the values of
                each cell in this column. Enter field width and
                number of fractional digits. A preceding count can be
                used to change more than one column.

Commands which move or copy cells also modify the row and column references in the new cell expressions. Use ``fixed'' or the ``$'' style cell reference to supress the change.

 @myrow, @mycol    return the row or column of the current cell

I: Range commands

 /x       Clear a range.
 /v       Remove the expressions from a range of cells, leaving
          just the values.
 /c       Copy a source range to a destination range.
 /f       Fill a range with constant values starting with a given
          value and increasing by a given increment.
 /d       Assign a name to a cell or a range of cells. Give the
          the name, surrounded by quotes, and either a cell name such
          as ``A10'' or a range such as ``a1:b20''.
 /l       Locks a cell or a range of cells, i.e makes it unchangeable.
 /U       Unlocks a locked cell, i.e makes it changeable.
 /s       Shows the currently defined range names.  Pipe output to
          sort, then to less.
 /u       Use this command to undefine a previously defined range name.
 /F       Assign a format string to a range of cells.

Range operations affect a rectangular region on the screen defined by the upper left and lower right cells in the region. A range is specified by giving the cell names separated by ``:'', such as ``a20:k52''. Another way to refer to a range is to use a name previously defined using ``/d''.

J: Miscellaneous commands

 Q q ^C       Exit from the program.
 ^G     ESC   Abort entry of the current command.
 ?            Help
 !            Shell escape.  Enter a command to run. ``!!'' repeats
              the last command. Just ``!'' starts an interactive shell.
 ^L           Redraw the screen.
 ^R           Redraw the screen. Highlight cells with values but no
 ^X           Redraw the screen. Show formulas, not values.
 @            Recalculate the spreadsheet.
 ^V           Type, in the command line, the name of the current cell.
 ^W           Type, in the command line, the current cell's expression.
 ^A           Type, in the command line, the current cell's numeric value.
 TAB          When the character cursor is on the top line TAB can be
              used to start or stop the display of the default range.

K: Variable names

 K20     Row and column can vary on copies.
 $K$20   Row and column stay fixed on copies.
 $K20    Row can vary; column stays fixed on copies.
 K$20    Row stays fixed; column can vary on copies.

fixed holds following expression fixed on copies. Cells and ranges can be given a symbolic name via ``/d''.


 -e      Negation                e<=e  Less than or equal
 e+e     Addition                e=e   Equal
 e-e     Subtraction             e!=e  Not Equal
 e*e     Multiplication          e>=e  Greater than or equal
 e/e     Division                e>e   Greater than
 e%e     Modulo                  e<e   Less than
 e^e     Exponentiation          e&e   Boolean operator AND
 ~e      Boolean operator NOT    e|e   Boolean operator OR
 e?e1:e2  or @if(e,e1,e2)
         Conditional: If e is non zero then then e1, else e2.

Terms may be constants, variables, and parenthesized expressions.

L: Range functions

 @sum(r)       Sum all valid cells in the range.
 @prod(r)      Multiply together all valid cells in the range.
 @avg(r)       Average all valid cells in the range.
 @count(r)     Count all valid cells in the range.
 @max(r)       Return the maximum value in the range.
 @min(r)       Return the minimum value in the range.
 @stddev(r)    Return the sample standard deviation of
               the cells in the range.
 @index(e,r) @stindex(e,r)
               Return the numeric (string) value of the cell at
               index e into range r.
 @lookup(e,r) @hlookup(e,r,n) @vlookup(e,r,n)
               Search through the range r for a value that
               matches e.  If e is numeric, the last value <= e
               matches; if string, an exact match is required.
               @lookup searches a single row (column) and returns
               the value from the next column (row); @hlookup
               (@vlookup) searches the first row (column) in r and
               returns the value n columns (rows) from the match.

M: Numeric functions

 @atan2(e1,e2)     Arc tangent of e1/e2.
 @ceil(e)          Smallest integer not less than e.
 @eqs(se1,se2)     1 if string expr se1 has the same value as se2.
 @exp(e)           Exponential function of e.
 @abs(e) @fabs(e)  Absolute value of e.
 @floor(e)         The largest integer not greater than e.
 @hypot(x,y)       Sqrt(x*x+y*y).
 @max(e1,e2,...)   The maximum of the values of the e's.
 @min(e1,e2,...)   The minimum of the values of the e's
 @nval(se,e)       The numeric value of a named cell.
 pi           @pi  A constant quite close to pi.
 @pow(e1,e2)       e1 raised to the power of e2.
 @rnd(e)           Round e to the nearest integer.
 @round(e,n)       Round e to n decimal places.
 @sqrt(e)          Square root of e.
 @ston(se)         Convert string expr se to a numeric
 @ln(e)   @log(e)  Natural/base 10 logarithm of e.
 @dtr(e)  @rtd(e)  Convert degrees to/from radians.
 @cos(e)  @sin(e)  @tan(e)   Trig functions of radian arguments.
 @asin(e) @acos(e) @atan(e)  Inverse trig function.

N: String functions

 #                 Concatenate strings. For example, the
                   string expression ``A0 # "zy dog"'' yields
                   ``the lazy dog'' if A0 is ``the la''.
 @substr(se,e1,e2) Extract characters e1 through e2     from the
                   string expression se.  For example,
                   ``@substr("Nice jacket" 4, 7)'' yields
                   ``e ja''.
 @fmt(se,e)        Convert a number to a string using sprintf(3).
                   For example, ``@fmt("*%6.3f*",10.5)'' yields
                   ``*10.500*''. Use formats are e, E, f, g, and G.
 @sval(se,e)       Return the string value of a cell selected by name.
 @ext(se,e)        Call an external function (program or
                   script). Convert e to a string and append it
                   to the command line as an argument. @ext yields
                   a string: the first line printed to standard
                   output by the command.
 @coltoa(e)        Return the column letter(s) from the passed number
 @upper(e) @lower(e)   Return the string in upper/lower case
 @capital(e)       Return the string with words in upper case

String expressions are made up of constant strings (characters surrounded by quotes), variables, and string functions.

O: Financial functions

 @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
                   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 com-
                   pounded monthly?''

 @pv(e1,e2,e3)     @pv(1000,.015,36) computes the present
                   value of an 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?''

P: Time and date functions

 @now              Return the time encoded in seconds since 1970.
 @dts(m,d,y)       Return m/d/y encoded in seconds since 1970.
 @tts(h,m,s)       Return h:m:s encoded in seconds since midnight.

All of the following take an argument expressed in seconds:

 @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 pieces of this fixed format
                   string with @substr.
 @year(e)          Return the year.  Valid years begin with 1970.
 @month(e)         Return the month: 1 (Jan) to 12 (Dec).
 @day(e)           Return the day of the month: 1 to 31.
 @hour(e)          Return the number of hours since midnight: 0 to 23.
 @minute(e)        Return the number of minutes since the
                   last full hour: 0 to 59.
 @second(e)        Return the number of seconds since the
                   last full minute: 0 to 59.

Burkhard Kirste, 1994/03/10