EXAMPLES:

	This help file contains some simple examples.

	1.) Compute mean and standard deviation of same random data.
	2.) Write a function to generate a Hilbert matrix.
		.
		.
		.


	**************************************************************

	1.) In this example we will randomly generate some data with a
	normal distribution. This data could be actual data sampled
	from an experiment, or simply artificial data generated as a
	means of testing some algorithms, whatever.

	1st lets set the random number generator so that it generates
	numbers from a normal distribution, with mean value of 5.0,
	and a standard deviation of 2.
	
	> rand( "normal", 5, 2 )
	           1

	Next we use rand() to generate a 1-by-100 matrix of random numbers.

	> x = rand(1,100);

	Then plot the data to make sure it is what you think it is.

	> plot( x' )

	Next, calculate the mean value, it had better be pretty close
	to 5.0.
	
	> norm(x')/x.n
	       5.096

	Likewise, calculate the standard deviation:

	> sqrt( norm( (x - mean)'.^2 )/x.n )
	       2.017

	If we were going to repeat these calculations we could create
	functions to do the task.

	> mean = function(x)
	  {
	    return norm(x)/x.n;
	  }

	> std = function(x)
	  {
	    return sqrt( norm( (x - mean(x)).^2 )/x.n );
	  }

	Then...

	> mean(x')
	       5.096

	> std( x' )
	       2.017

	Plot the probability density function:

	> for(i in 0:10)
	  {
	    dens[i+1] = sum( x <= i+1 );
	  }
	> plot( dens' )

        100 ++-----------+------------+-----------+---------*****************
            +            +            +           +     ****   +            +
         90 ++......................................****....CONSTANT-1.****++
         80 ++...................................***.......................++
            |            :            :        ** :            :            |
         70 ++...............................**............................++
            |            :            :     *     :            :            |
         60 ++............................**...............................++
         50 ++...........................*.................................++
            |            :            :**         :            :            |
         40 ++.......................**....................................++
            |            :       **** :           :            :            |
         30 ++................***..........................................++
            |            : ***        :           :            :            |
         20 ++........*****................................................++
         10 ++.*******.....................................................++
            ***          +            +           +            +            +
          0 ++-----------+------------+-----------+------------+-----------++
            0            2            4           6            8           10


	Note: More robust implementations of mean(), and std() can be
	found in the RLaB library.

 	**************************************************************

	2.) The following function will generate a Hilbert matrix.

	//-------------------------------------------------------
	//
	// Generate a NxN Hilbert matrix.
	//
	
	hilb = function(n)
	{
	  local(i,j,h);
	
	  for(i in 1:n) {
	    for(j in 1:n) 
	      h[i;j] = 1/(i+j-1);
	    }
	  }
	  return h;
	}

	//-------------------------------------------------------


	This function could be typed in from the command line, but it
	is easier to create it in a text editor and have RLaB read the
	file with the load function. 

	> load("hilbert.r")
	           1
	parse error on line: 11, file: hilbert.r
	      h
	      ^
	
	Oops, we goofed. The error message tells us there is a parser
	error (which is similar to a compilation error) on line 11 of
	hilbert.r. Looking at the file, we see that an opening `{' was
	missing from the inner for-loop, we fix it, and:

	> load("hilbert.r")
	           1
	> hilb(4)
	 matrix columns 1 thru 4
	           1         0.5      0.3333        0.25
	         0.5      0.3333        0.25         0.2
	      0.3333        0.25         0.2      0.1667
	        0.25         0.2      0.1667      0.1429


	Now suppose we want to see how the condition number of a
	Hilbert matrix varies with the size of the matrix:


	> for( i in 2:8 ) 
	  {
	    1/rcond( hilb( i ) )
	  }
	          27
	         748
	   2.837e+04
	   9.437e+05
	   2.907e+07
	   9.852e+08
	   3.387e+10
	
	If we want to be more elaborate we could...

	> for( i in 2:8 ) 
	  {
	    printf( "Hilbert size = %i, condition no. = %f\n",...
                      i, 1/rcond( hilb( i ) ) );
	  }
	Hilbert size = 2, condition no. = 27.000000
	Hilbert size = 3, condition no. = 748.000000
	Hilbert size = 4, condition no. = 28375.000000
	Hilbert size = 5, condition no. = 943655.999999
	Hilbert size = 6, condition no. = 29070279.001162
	Hilbert size = 7, condition no. = 985194887.261002
	Hilbert size = 8, condition no. = 33872789110.107353

	**************************************************************


		.
		.
		.