			Release notes for rs		(v 2.0c  Dec 09)

	rs 2.0a, rs 2.0b, & rs 2.0c fixed bugs.

	There is still a bug related to projections.  It may be
most obvious if the data are plotted, since the plotting software
projects the x and y variables.  The workaround for this bug is
to disable SELPROJ_OPTIMIZE (referred to below).  Apologies for
the difficulty.

	rs 2.0 introduces a new "levelization operator" in addition
to the colon.  The new operator is the pound sign (#).  It is used
similarly to the colon, between a level and a variable name, to
create a levelization argument.
	rs levelizes its output according to its levelization arguments.
It also compresses its output if 2 consecutive lines are identical.
This compression is not always desirable.  For one example, the
variables might be physical parameters like temperature that might
have consecutive identical data that should be treated as 2 observations.
For another example, consecutive lines that are different if all
variables are looked at can become identical if variables are projected
out.
	The pound sign operator means "levelize but do not compress".
Its most frequent use would probably be for the "all the rest at
lowest level" levelization argument; eg, if a 3 level object "concludes"
with a 2:* argument with existing versions of rs, it may be better to
change this to a 2#* argument with rs 2.0.

	rs 2.0 includes more rigorous handling of input
arguments.  In particular, the levelization arguments and the variable
list of the input object must match in the sense that all variables in
levelization arguments must be in the object's variable list and all
variables in object must be in some levelization argument.  The latter
condition is most easily handled by having a "level#*" levelization
argument.
	Other changes include accepting levelization arguments in
any order.

	rs 2.0 honors the SELPROJ_OPTIMIZE switch to attempt to improve
performance.  Please see the documentation for this switch, included
with the outer release beginning w/outer version 3.0b.

==============================

 	For example purposes, consider the following rs situation.
rs uses the output of another method and flattens it before proceeding.
Suppose that method produces the following data that flatten into
	key1 key2 key2a key3 datum
	X    A    p     q    1.0
	X    B    p     q    1.0
	X    A    p     q    1.0

Suppose this dataset is to be levelized w/the following parameters
0:key1 1:key2 1:key2a 2:key3 3:datum

=====

Example 1 - projection

Suppose key2 is projected out of the dataset.


Unoptimized behavior will produce output
	key1 key2a key3 datum
	X    p     q    1.0
	X    p     q    1.0
	X    p     q    1.0
because the key2 data are available to rs before the projection is
done.  The distinct key2 data produce the 3 output lines.


However, if the projection request is passed to the other method,
the other method will provide, for input to rs,
	key1 key2a key3 datum
	X    p     q    1.0
	X    p     q    1.0
	X    p     q    1.0

rs will take this and produce output of
	key1 key2a key3 datum
	X    p     q    1.0

=====

Example 2 - selection

Suppose there is a selection of the form   key2 eq A


Unoptimized behavior will produce output
	key1 key2 key2a key3 datum
	X    A    p     q    1.0
	X    A    p     q    1.0
because rs will have used the B value for key2 to retain all
3 "input lines".  Subsequent selection then eliminates the B line


However, if the selection request is passed to the other method,
the other method will provide, for input to rs,
	key1 key2 key2a key3 datum
	X    A    p     q    1.0
	X    A    p     q    1.0

rs will take this and produce output of
	key1 key2 key2a key3 datum
	X    A    p     q    1.0
