	Verbs are essentially commands or operators built into UniPOPS
	which perform  various  analysis,  book-keeping,  and  display
	operations.  Some verbs are fully stand-alone in that they do
	not require any arguments.  Others have their operations
	influenced by the values of different adverbs, while yet
	another set take one or more arguments.

	UniPOPS also provides a set of mathematical and logical
#if XPLN
	operators (see the documentation on Math), and mathematical
#else
	operators (see the Cookbook, Chapter 14), and mathematical
#end 
	functions so the user can perform complex calculations.  Users
	of UniPOPS have the ability to write procedures, a user-defined
	subroutine or function composed of calls to other procedures or
	UniPOPS verbs and adverbs.  You can also rename any verb to
	whatever name you like (see ALIAS).


Types of Verbs
--------------

	There are 4 types of verbs.

#if RFRNC
		   Table 5.1.1 : Types of UniPOPS Verbs
#else
		   	Types of UniPOPS Verbs
#end
	-----------------------------------------------------------------
	Type of Verb :		Description:
	-----------------------------------------------------------------
	Function Verbs          Similar to the math and string
				  functions found in most computer
				  languages.
	Internal-Array Verbs    Similar in usage to, but more
				  restrictive, than array adverbs.
	Pseudo Verbs		A special class of verbs, similar to
				  Fortran subroutines, but can only
				  be used while in execute mode.
	Regular Verbs		Similar to subroutines in Fortran that
				  are supplied by the system and which
				  the user cannot modify.
	-----------------------------------------------------------------

	Function Verbs 
	-------------- 
		Function verbs are like Fortran or C functions in that
		they return a value.  Since they return a value, they
		can be used in mathematical expressions, as arguments
		(operands) other verbs and as arguments to procedures.
		Note that there are some function verbs that return
		a string.  Function verbs that return strings have the
		same limitations as string adverbs.

	Internal-Array Verbs
	--------------------
		Internal-array verbs are very similar to array adverbs.  
		Large arrays for storing data are most often not adverbs 
		but reside internal to the UniPOPS program.  You use the
		internal-array verbs in almost the same way you would
		use an array adverb except for the restrictions we
		mention under "Use of Verbs" below.

	Pseudo Verbs
	------------
		Pseudo verbs must be the only command on the command line
		and they cannot be used within procedures.  Most are related 
		to system functions (and would prove disastrous if you
		were able to use them in procedures) or require
		arguments whose syntax does not follow the standard
		conventions.

	Regular Verbs
	-------------
		Regular verbs are the most common type of verb.  They do 
		not return a value, they cannot be used in mathematical 
		expressions, and they cannot appear to the right of an 
		assignment operator, "=".  Multiple regular verbs can be 
		typed on the same command line and they can be used within 
		procedures.


Uses of Verbs
-------------

	Regular and Pseudo Verbs
	------------------------
	Before using a verb, you may be required to set values to
	adverbs used by that verb.  The documentation for each verb
	will tell you what adverbs you should give values to and what
	those values mean.  Typing HELP <verbname>, where <verbname> is
	the name of any verb, will list for you a short description of
	the verb, the arguments you should supply the verb, plus a list
	of adverbs (and their current values) used by that verb.  For
	more information on a particular verb, type EXPLAIN <verbname>.

	To use any verb, just type its name followed by any arguments
	the verb requires.  The documentation for each verb will tell
	you what the number and type of arguments are for each verb.
	For verbs (and procedures) requiring more than one argument,
	the argument list must be separated by commas an enclosed within
	parentheses (single arguments can also be enclosed within
	parenthesis but this is not required).

	Some pseudo verbs require you to provide arguments in a
	different format than regular verbs require (see the
	documentation on pseudo verbs or on command syntax).

	Some verbs alter the value of certain adverbs as a result of 
	their action.  Again, the documentation for each verb will make 
	this clear.

	EXAMPLES :

	.  MOMENT is a regular verb requiring you to set values to
	   adverbs EMOMENT and BMOMENT.  MOMENT sets the array adverb
	   SIZE to the results of the moment calculation.

		BMOMENT=123; EMOMENT=456; MOMENT PRINT SIZE

	   will set up the adverbs, execute MOMENT, and print out the
	   results.

	.  The verb ADDSTACK uses and sets no adverbs but does require 
	   three real-valued arguments.  A typical usage of ADDSTACK 
	   would be:

		ADDSTACK(12, N*14, INCR)

	   Note that the second argument contains a multiplication.

	.  The pseudo verb CHNGPRJ requires one argument -- a string --
	   that should not be enclosed in quotes (unlike must verbs
	   that take string arguments).  So, you type:

		CHNGPRJ K332

	.  CHNGFILE is a pseudo verb that takes zero, two, or three arguments.
	   So, you could type one of the following:

		CHNGFILE
		CHNGFILE SUBTRACT 11
		CHNGFILE CREATE 2 Orion.Keep

	   Note that although this verb can take more than one argument,
	   the arguments are not separated by commas and enclosed in
	   parenthesis.  You should consult the documentation for each
	   pseudo verb to ensure that the correct syntax is used.

	Function Verbs
	--------------
	You should think of function verbs as identical in usage to functions
	in Fortran or C.  That is, you provide the function with the
	arguments it requires and acts on and the function returns a
	single value back.  

	Most functions return real (floating-point) values but a handful
	return strings.

	Examples:

	.  The function RAND returns a pseudo random number between 1 and -1.
	   To assign a random value to adverb X, you could type:

		X = RAND

	.  The function MOD takes the modulus of its two arguments (i.e., the
	   remainder function).  To print out the remainder after dividing
	   X by 12, type:

		PRINT MOD(X,12) 

	.  The function CONCAT takes two strings as arguments as returns a 
	   single string which is the concatenation of the two arguments.
	   If HTITLE and YTITLE are string adverbs, you could type:

		HTITLE = CONCAT('Hello', YTITLE)


	Internal-Array Verbs
	--------------------

	The very few internal-array verbs in UniPOPS are:

		D0	D1	D2	D3	D4	D5	D6
		D7	D8	D9	H0	H1	H2	H3
		H4	H5	H6	H7	H9	MD0	MD1
		MD2	MD3	MH0	MH1	MH2	MH3	CH0
		CD0	ASTACK

	The functions of these verbs are summarized in the following table:

#if RFRNC
		   Table 5.1.2 : Internal-Array Verbs
#else
		   	Internal-Array Verbs
#end
	-----------------------------------------------------------------
	Name of Verb :		Description:
	-----------------------------------------------------------------
	D0 through D9           For setting or retrieving the values of
				the data in internal one-dimensional
				data Arrays (0) through (9).
				Requires one argument.
	H0 through H9           For setting or retrieving the values of
				the header parameters to the internal
				one-dimensional data Arrays (0) through
				(9).  Requires one argument.
	MD0 through MD3         For setting or retrieving the values of
				the data in internal two-dimensional
				data Matrices (0) through (3).
				Requires two arguments.
	MH0 through MH3         For setting or retrieving the values of
				the header parameters to the internal
				two-dimensional data Matrices (0)
				through (3).  Requires one argument.
	CD0                     For retrieving the values of the data
				in internal three-dimensional data
				cube.  Requires three arguments.
	CH0                     For retrieving the values of the header
				parameters to the in internal
				three-dimensional data cube.  Requires
				one argument.
	ASTACK			For setting or retrieving the values of
				the internal ASTACK array.  Requires
				one argument.
	-----------------------------------------------------------------

	Internal-array verbs are restricted in their usage in
	comparison to array adverbs in that they cannot appear without
	their arguments.

	For example, array adverbs can be assigned values with one
	of the following:

		NREGION = 32

	        (i.e., all elements of NREGION are assigned a value of 32).

		READ NREGION

		(i.e., you will be prompted to input a value of all elements
		of NREGION.)


	Array adverbs can also appear in a PRINT statement as follows:

		PRINT NREGION

		(will print every element of array NREGION). 

	Internal-array verbs, on the other hand, can only be printed
	or assigned values with statements like the following:

		PRINT MD0(1,3)
		D0(I) = 32

	They also cannot appear in READ statements!

	That is, the following are illegal:

		MH0 = 34
		READ D0(1,1)
		PRINT MD0

	In addition, the cube internal-array verbs are read only.  They
	cannot appear on the left side of the assignment operator, "=".
