sc man page on 4.4BSD

Man page or keyword search:  
man Server   1065 pages
apropos Keyword Search (all sections)
Output format
4.4BSD logo
[printable version]

SC(1)									 SC(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.

       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 ALSO
       bc(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)
[top]

List of man pages available for 4.4BSD

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
...................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net