MATRIX:

	The MATRIX object is the fundamental data object in RLaB.
	Matrices are dynamic data structures that can be created,
	enlarged, or destroyed by the user. Matrices can be real or
	complex numeric, or they can contain strings.

	Creating a matrix interactively is simple:

	m = [1,2,3;4,5,6;7,8,9];

	or

	m = [1,2,3;
	     4,5,6;
	     7,8,9]

	or

	m=[1,2,3;4,5,...
	   6;7,8,9]

	As you can see the syntax is similar to MATLAB, except you
	cannot leave out the commas. However, you can break the line
	at the semicolon, but ONLY at the semicolon, and the semicolon
	cannot be left out.

	Matrices can be composed of other scalars, vectors and
	matrices...

	> s = 1;
	> v = 4:6;
	> m = [s, 2, 3; v]
	 m =
	 matrix columns 1 thru 3
	           1           2           3
	           4           5           6
 
	To extract, or assign to matrix elements:

	> m[1;1]
	           1
	> m[1;1] = 100
	 m =
	 matrix columns 1 thru 3
	         100           2           3
	           4           5           6

	When assigning values to matrix elements index checking is
	automatically performed. When an index value exceeds the
	dimension of the matrix, the size of the matrix is
	automatically extended to accommodate the new value.

	clear(m);
	m[1;1] = 10;

	Then the variable is automatically converted to a matrix
	object, and sized appropriately.

	The following works, but is very inefficient:

	for(i in 1:4) {
	  for(j in 1:4) {
	    a[i;j] = i+j;
	  }
	}

	since we are constantly extending the size of the matrix.
	However, it is very convenient.

	Vectors can be used as matrix index values:

	> a=[1,2,3,4;5,6,7,8;9,10,11,12]
	 a =
	 matrix columns 1 thru 4
	           1           2           3           4
	           5           6           7           8
	           9          10          11          12

	> a[2,3;2,3]
	 matrix columns 1 thru 2
	           6           7
	          10          11

	> a[2;]
	 matrix columns 1 thru 4
	           5           6           7           8

	> a[;2]
	 matrix columns 1 thru 1
	           2
	           6
	          10
	
	> a[;2] = 200,600,1000
	 a =
	 matrix columns 1 thru 4
	           1         200           3           4
	           5         600           7           8
	           9       1e+03          11          12

	Matrix properties can be obtained from functions such as:
	class(), type(), and size(). Additionally they can be obtained
	by using the LIST-like syntax to reference the data:

	> m=[1,2,3;4,5,6;7,8,9;10,11,12]
	 m =
	 matrix columns 1 thru 3
	           1           2           3
	           4           5           6
	           7           8           9
	          10          11          12
	> m.class
	matrix
	> m.type
	real
	> m.nr
	           4
	> m.nc
	           3
	> m.n
	          12
	> show(m)
	   name:      m       
	   class:     matrix  
	   type:      real    
	     nr:      4       
	     nc:      3       

	The show() function shows all of the available entity
	information as once.

	Matrices can also be used like single dimension arrays. Any
	matrix can be indexed with a single dimension `m[i]'. The
	effect is to walk the matrix in a column fashion, thus:

	> m
	 m =
	 matrix columns 1 thru 3
	           1           2           3
	           4           5           6
	           7           8           9
	          10          11          12
	> m[1]
	           1
	> m[2]
	           4
	> m[3]
	           7

	Matrices can also be forced into the shape of a column vector
	with the `[:]' operator.

	> m[:]
	 matrix columns 1 thru 1
	        1  
	        4  
	        7  
	       10  
	        2  
	        5  
	        8  
	       11  
	        3  
	        6  
	        9  
	       12  

 	String Matrices:

	Matrices can also contain STRINGS. The individual members are
	the same as RLaB's scalar STRING object. The syntax for
	creating a string matrix is the same as a numerical matrix,
	except the elements are strings, and not numbers.

	> sm = [ "s-element-1,1", "s-element-1,2";
	>        "s-element-2,1", "s-element-2,2"]
	 sm =
	s-element-1,1  s-element-1,2  
	s-element-2,1  s-element-2,2  

	> sm[1;2]
	s-element-1,2
	> sm[3]
	s-element-1,2

	> show( sm )
	   name:      sm      
	   class:     matrix  
	   type:      string  
	     nr:      2       
	     nc:      2       
	> show( sm[1;1] )
	   name:           
	   class:  string  
	       l:  13      
