RLaB offers more than the matrix as a data type. However, the matrix is probably the most often used data structure. Like Matlab, RLaB's matrices are used to represent scalars, vectors, and matrices, both real and complex. At this point in time RLaBdoes not offer a sparse matrix.
In addition to the matrix, RLaB has a string class, and data type. A string is a variable length collection of characters. Both string vectors, and string matrices are supported. One advantage to the addition of this type is the ability to collect strings of different lengths in the same vector or matrix.
However, the most significant improvement is RLaB's list class. A list is a heterogeneous associative array that can contain any data type, including other lists. The list gives RLaBusers the opportunity to structure their data as necessary. Some possible uses are:
- Lists can be used to store vectors or matrices of
differing sizes that need similar processing. For
example, you might have several vectors of differing
length, each representing some time-series data. You
might want to process them all in a similar fashion,
such as apply spectral transformations or collect
statistics. In Matlab you are forced to use separate
vectors, or some special functions to ``pack'' the
vectors into a dense or sparse array. In RLaByou can
simply create a list containing each vector:
for (i in 1:N) { ldata.[i] = readm ("datafile." + num2str (i)); }Now the list,
ldatacan be passed to a function for processing:process_data (ldata). - Lists can be used to store data ``objects''. For
example: suppose we are performing simulations of
dynamic systems. We might represent our system as a
state-space model. Typically a state-space model
consists of four coefficient matrices:
![$[A], [B], [C],
[D]$](img1.png)
. Instead of handling each matrix as a distinct
matrix, we could group them together, and use functions
to operate upon each state space model as a whole:
ss1 = ss_create ( freqv, dampv ) // Create a state-space model // from frequencies and damping. ss1.bode = ss_bode ( ss1, IN, JW ) // Compute Bode plot for state-space // model.In these situations the list helps the user/programmer organize the data in sensible ways that can reduce confusion.
- The heterogeneous nature of lists will become more
apparent as we look at this last example. RLaBhas a
function called getline, which is somewhat like the AWK
getline function. Getline gets a line of ASCII text from
a file, parses the line on whitespace, and returns the
results in a list, where the first element contains the
contents of the first field, the second element contains
the contents of the second field, and so on. Getline is
smart enough to distinguish numbers from ordinary text,
and the returned list can contain both types of
objects2.
In this example we will read a data-file that contains some test output. The engineer doing the test annotated each row of test output with a label. We would like to maintain the label, and use it from within RLaB. The file looks like:
sensor1 0.162 0.665 0.0847 0.204 0.167 sensor2 0.655 0.129 0.91 control 0.112 0.299 0.265 0.7
We can read this data, and maintain the strings as labels by:
> while (length (line = getline ("test.data"))) { test_data.[line.[1]] = get_test_vector (line); } > test_data test_data = control sensor1 sensor2 > test_data.sensor1 sensor1 = 0.162 0.665 0.0847 0.204 0.167As you can see, the data is now stored in a list, with element names from the first field of
test.data. Each element is a numeric vector, which contains the rest of the data in each row.get_test_vectoris a simple nine-line function that returns all but the first element as a vector.
- Only one function is allowed in a file.
- Function arguments are passed by value. This in itself
is not good or bad. However it is somewhat limiting to only
allow one method.
- All variables, except those declared global are
local. There are only two scoping possibilities. There is no
way to hide data (data abstraction).
In RLaB, we try to overcome these limitations with the following:
- Users can put as many function definitions in a file as
desired, there are no limitations.
- Function arguments can be passed by value and reference.
- In addition to global and function-local variables,
there are also file-static variables. Variables can be
declared static within a file. These variables are hidden from
the global environment and other files. Only the functions
within the file (and after the declaration) have access to the
variable.
fprintf can be used to send
commands or data to a process
fprintf ("| gnuplot", "plot %s using 1:3\n", tmp_file_name);
Or readm can be used to read the output of a filter on
some pre-existing data.
x = readm ("| awk -f data_filter.awk < orig_data");
In RLaB expressions usually (most always) have a result. You can figure out for yourself what the result of a particular statement will be by evaluating each sub-expression, starting at the lowest level, and combining the results, until you have the answer. Sometimes this is called a substitution model of evaluation. When using RLaB there should be less idiosyncrasies to deal with.
RLaB offers a much simpler data visualization capability. RLaB graphics are handled through a scientific graphics library called Plplot. The Plplot API is implemented as a set of builtin functions within RLaB. Thus, the high level plotting capabilities are handled by RLaB programs. Two and three dimensional plots, contours, and histograms, with a host of options are supplied. Custom plots are can be created by utilizing the low-level Plplot API. The most popular output devices (screens and printers) are supported. When using X-windows, there is a nice ``plot-widget'' that allows the user to zoom and pan, print plots, and tweak the color-maps.
If you need really ``gee--whiz--turbo--object--oriented'' graphics, you ought to be looking at Matlab. If you need a good programming language that offers good data visualization, then RLaB deserves a look.
RLaB's linear algebra functions are mostly supplied by the
source code from the LAPACK project. LAPACK could be called
``LINPACK + EISPACK 
Edition''. The LAPACK
functions offer some block structured algorithms, and utilize
levels 2 and 3 BLAS. Thus, on some machines they may provide
better performance.