OPERATORS:

	DEFINITION: An operator is a symbol(s) that takes operand(s)
	as input, and computes a result(s) that is a function of the
	operand(s).

	We can draw an analogy between operators and functions. The
	operands are analogous to a functions arguments, and the
	operation result is analogous to the functions return
	value(s). Any symbol that does not fit this definition of an
	operator is a delimiter. For example: the semi-colon, `;' is
	NOT an operator. A user cannot use the semi-colon to generate
	a tangible result.

	Relational and logical operators are discussed in the
	help-file `RELATIONAL' (see `help RELATIONAL').

	Valid unary operators (operators that operate on a SINGLE object)

	+	unary plus
	-	unary minus
	++	increment
	--	decrement
	'	MATRIX transpose

	Note: the increment and decrement operators are NOT exactly
	like the C post-increment and post-decrement. RLaB inc/decs
	the value of the variable immediately.

	Valid binary operators (operate on two objects)

	+	addition
	-	subtraction
	*	multiplication
	.*	multiplication
	/	right division			(see DIVISION)
	./	el-by-el right division		(see DIVISION)
	\	left division			(see DIVISION)
	.\	el-by-el left division		(see DIVISION)
	^	power
	.^	el-by-el power

	The binary operators are supposed to function like their
	MATLAB counterparts. 

	Following are the rules used for applying the binary operators.

	Miscellaneous (but very important) operators.

	,	concatenation (inside `[' `]' only)
	:	vector construction
	[ ]	matrix construction, and MATRIX element reference.

	The `:' operator is used to build vectors (a 1xN matrix) with
	regular intervals (default interval = 1).

	> 1:10

	builds the vector `1,2,3,4,5,6,7,8,9,10'

	> 1:2:.5

	builds the vector `1,1.5,2'

	This 1st operand is the vector start value, the 2nd operand is
	the vector end value, and the 3rd operand is the vector
	increment. 

	The `;' is the RLaB separator. In some ways it acts as a
	vertical append operator, but since it is not accessible to
	users as an explicit operator, it is a delimiter.

	The `[' and `]' serve a dual function. The first is to serve
	as the MATRIX construction operators. Enclose an expression
	with `[' and `]' and RLaB will try and make a MATRIX out of
	the expression.

	The second function of `[' and `]' is to serve as the MATRIX
	element reference operators, thus:

	> m=[1,2,3;4,5,6;7,8,9]
	 m =
	 matrix columns 1 thru 3
	           1           2           3
	           4           5           6
	           7           8           9

	builds a matrix, and assigns it to `m'. To reference the
	element in the 2nd row, and 2nd column:

	> m[2;2]
	           5

	Reference the 2-by-2 sub-matrix formed by extracting the 1st
	and 2nd rows, and switching the 2nd and 1st columns.

	> m[1,2;2,1]
	 matrix columns 1 thru 2
	           2           1
	           5           4
