StructureClasses           package:methods           R Documentation

Classes Corresponding to Basic Structures

Description:

     The virtual class 'structure' and classes that extend it are
     formal classes analogous to S language structures such as arrays
     and time-series.

Usage:

     ## The following class names can appear in method signatures,
     ## as the class in as() and is() expressions, and, except for
     ## the classes commented as VIRTUAL, in calls to new()

     "matrix"
     "array"
     "ts"

     "structure" ## VIRTUAL

Objects from the Classes:

     Objects can be created by calls of the form 'new(Class, ...)',
     where 'Class' is the quoted name of the specific class (e.g.,
     '"matrix"'), and the other arguments, if any, are interpreted as
     arguments to the corresponding function, e.g., to function
     'matrix()'.  There is no particular advantage over calling those
     functions directly, unless you are writing software designed to
     work for multiple classes, perhaps with the class name and the
     arguments passed in.

     Objects created from the classes '"matrix"' and '"array"' are
     unusual, to put it mildly, and have been for some time.  Although
     they may appear to be objects from these classes, they do not have
     the internal structure of either an S3 or S4 class object.  In
     particular, they have no '"class"' attribute and are not
     recognized as objects with classes (that is, both 'is.object' and
     'isS4' will return 'FALSE' for such objects).

     That the objects still behave as if they came from the
     corresponding class (most of the time, anyway) results from
     special code recognizing such objects being built into the base
     code of R. For most purposes, treating the classes in the usual
     way will work, fortunately.  One consequence of the special
     treatment is that these two classes_may_ be used as the data part
     of an S4 class; for example, you can get away with 'contains =
     "matrix"' in a call to 'setGeneric' to create an S4 class that is
     a subclass of '"matrix"'.  There is no guarantee that everything
     will work perfectly, but a number of classes have been written in
     this form successfully.

     The class '"ts"'  is basically an S3 class that has been
     registered with S4, using the 'setOldClass' mechanism.  Versions
     of R through 2.7.0 treated this class as a pure S4 class, which
     was in principal a good idea, but in practice did not allow
     subclasses to be defined and had other intrinsic problems.  (For
     example, setting the '"tsp"' parameters as a slot often fails
     because the built-in implementation does not allow the slot to be
     temporarily inconsistent with the length of the data. Also, the S4
     class prevented the correct specification of the S3 inheritance
     for class '"mts"'.)

     The current behavior (beginning with version 2.8.0 of R) registers
     '"ts"' as an S3 class,  using an S4-style definition (see the
     documentation for 'setOldClass' in the examples section for an
     abbreviated listing of how this is done.  The S3 inheritance of
     '"mts"' in package 'stats' is also registered. These classes, as
     well as '"matrix"' and '"array"' should be valid in most examples
     as superclasses for new S4 class definitions.

Extends:

     The specific classes all extend class '"structure"', directly, and
     class '"vector"', by class '"structure"'.

Methods:


     coerce Methods are defined to coerce arbitrary objects to these
          classes, by calling the corresponding basic function, for
          example, 'as(x, "matrix")' calls 'as.matrix(x)'.

     Ops, Math Group methods (see, e.g., 'S4groupGeneric') are defined
          for combinations of structures and vectors (including special
          cases for array and matrix), implementing the concept of
          vector structures as in the reference.


References:

     Chambers, John M. (2008) _Software for Data Analysis: Programming
     with R_ Springer.  (For the R version.)

     Chambers, John M. (1998) _Programming with Data_ Springer (For the
     original S4 version.)

     Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
     Language_. Wadsworth & Brooks/Cole (for the original vector
     structures).

Examples:

     showClass("structure")

     ## explore a bit :
     showClass("ts")
     (ts0 <- new("ts"))
     str(ts0)

     showMethods("Ops") # six methods from these classes, but maybe many more

