table                  package:base                  R Documentation

_C_r_o_s_s _T_a_b_u_l_a_t_i_o_n _a_n_d _T_a_b_l_e _C_r_e_a_t_i_o_n

_D_e_s_c_r_i_p_t_i_o_n:

     'table' uses the cross-classifying factors to build a contingency
     table of the counts at each combination of factor levels.

_U_s_a_g_e:

     table(..., exclude = c(NA, NaN), dnn = list.names(...), deparse.level = 1)
     as.table(x, ...)
     is.table(x)

     ## S3 method for class 'table':
     as.data.frame(x, row.names = NULL, optional = FALSE, ...)

_A_r_g_u_m_e_n_t_s:

     ...: objects which can be interpreted as factors (including
          character strings), or a list (or data frame) whose
          components can be so interpreted

 exclude: values to use in the exclude argument of 'factor' when
          interpreting non-factor objects; if specified, levels to
          remove from all factors in ....

     dnn: the names to be given to the dimensions in the result (the
          _dimnames names_).

deparse.level: controls how the default 'dnn' is constructed.  See
          details.

       x: an arbitrary R object, or an object inheriting from class
          '"table"' for the 'as.data.frame' method.

row.names: a character vector giving the row names for the data frame.

optional: a logical controlling whether row names are set. Currently
          not used.

_D_e_t_a_i_l_s:

     If the argument 'dnn' is not supplied, the internal function
     'list.names' is called to compute the 'dimname names'.  If the
     arguments in '...' are named, those names are used.  For the
     remaining arguments, 'deparse.level = 0' gives an empty name,
     'deparse.level = 1' uses the supplied argument if it is a symbol,
     and 'deparse.level = 2' will deparse the argument.

     Only when 'exclude' is specified (i.e., not by default), will
     'table' drop levels of factor arguments potentially.

_V_a_l_u_e:

     'table()' returns a _contingency table_, an object of 'class'
     '"table"', an array of integer values.

     There is a 'summary' method for objects created by 'table' or
     'xtabs', which gives basic information and performs a chi-squared
     test for independence of factors (note that the function
     'chisq.test' in package 'ctest' currently only handles 2-d
     tables).

     'as.table' and 'is.table' coerce to and test for contingency
     table, respectively.

     The 'as.data.frame' method for objects inheriting from class
     '"table"' can be used to convert the array-based representation of
     a contingency table to a data frame containing the classifying
     factors and the corresponding counts (the latter as component
     'Freq').  This is the inverse of 'xtabs'.

_R_e_f_e_r_e_n_c_e_s:

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

_S_e_e _A_l_s_o:

     Use 'ftable' for printing (and more) of multidimensional tables.

_E_x_a_m_p_l_e_s:

     require(stats) # for rpois and xtabs
     ## Simple frequency distribution
     table(rpois(100,5))
     data(warpbreaks)
     attach(warpbreaks)
     ## Check the design:
     table(wool, tension)
     data(state)
     table(state.division, state.region)
     detach()

     data(airquality)
     # simple two-way contingency table
     with(airquality, table(cut(Temp, quantile(Temp)), Month))

     a <- letters[1:3]
     table(a, sample(a))                    # dnn is c("a", "")
     table(a, sample(a), deparse.level = 0) # dnn is c("", "")
     table(a, sample(a), deparse.level = 2) # dnn is c("a", "sample(a)")

     ## xtabs() <-> as.data.frame.table() :
     data(UCBAdmissions) ## already a contingency table
     DF <- as.data.frame(UCBAdmissions)
     class(tab <- xtabs(Freq ~ ., DF)) # xtabs & table
     ## tab *is* "the same" as the original table:
     all(tab == UCBAdmissions)
     all.equal(dimnames(tab), dimnames(UCBAdmissions))

     a <- rep(c(NA, 1/0:3), 10)
     table(a)
     table(a, exclude=NULL)
     b <- factor(rep(c("A","B","C"), 10))
     table(b)
     table(b, exclude="B")
     d <- factor(rep(c("A","B","C"), 10), levels=c("A","B","C","D","E"))
     table(d, exclude="B")

     ## NA counting:
     is.na(d) <- 3:4
     d <- factor(d, exclude=NULL)
     d[1:7]
     table(d, exclude = NULL)

