StructureClasses           package:methods           R Documentation

_C_l_a_s_s_e_s _C_o_r_r_e_s_p_o_n_d_i_n_g _t_o _B_a_s_i_c _S_t_r_u_c_t_u_r_e_s

_D_e_s_c_r_i_p_t_i_o_n:

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

_U_s_a_g_e:

     ## 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

_O_b_j_e_c_t_s _f_r_o_m _t_h_e _C_l_a_s_s_e_s:

     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.

_E_x_t_e_n_d_s:

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

_M_e_t_h_o_d_s:


     _c_o_e_r_c_e 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)'. If 'strict =
          TRUE' in the call to 'as()', the method goes on to delete all
          other slots and attributes other than the 'dim' and
          'dimnames'.

     _O_p_s 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.  Essentially,
          structures combined with vectors retain the structure as long
          as the resulting object has the same length.  Structures
          combined with other structures remove the structure, since
          there is no automatic way to determine what should happen to
          the slots defining the structure.

          Note that these methods will be activated when a package is
          loaded containing a class that inherits from any of the
          structure classes or class '"vector"'.


_R_e_f_e_r_e_n_c_e_s:

     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).

_S_e_e _A_l_s_o:

     Class nonStructure, which enforces the alternative model, in which
     all slots are dropped if any math transformation or operation is
     applied to an object from a class extending one of the basic
     classes.

_E_x_a_m_p_l_e_s:

     showClass("structure")

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

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