as.vector 矩阵向量化

将矩阵向量化有时候是必要的。矩阵的向量化可以通过as.vector()来实现：

> A
     [,1] [,2] [,3] [,4]
[1,]    1    4    7   10
[2,]    2    5    8   11
[3,]    3    6    9   12

将矩阵元素向量化, 注意是逐列转换的：

> as.vector(A)
 [1]  1  2  3  4  5  6  7  8  9 10 11 12

如果要逐行转换, 可以使用t转换一下 : 

> as.vector(t(A))
 [1]  1  4  7 10  2  5  8 11  3  6  9 12

将矩阵的方阵部分元素向量化：

> dim(A)
[1] 3 4
> ncol(A)
[1] 4
> nrow(A)
[1] 3
> A[1:min(dim(A)),1:min(dim(A))]
     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9
> as.vector(A[1:min(dim(A)),1:min(dim(A))])
[1] 1 2 3 4 5 6 7 8 9

[参考]

1. > help(as.vector)

vector                  package:base                   R Documentation

Vectors

Description:

     ‘vector’ produces a vector of the given length and mode.

     ‘as.vector’, a generic, attempts to coerce its argument into a
     vector of mode ‘mode’ (the default is to coerce to whichever
     vector mode is most convenient): if the result is atomic all
     attributes are removed.

     ‘is.vector’ returns ‘TRUE’ if ‘x’ is a vector of the specified
     mode having no attributes _other than names_.  It returns ‘FALSE’
     otherwise.

Usage:

     vector(mode = "logical", length = 0)
     as.vector(x, mode = "any")
     is.vector(x, mode = "any")
     
Arguments:

    mode: character string naming an atomic mode or ‘"list"’ or
          ‘"expression"’ or (except for ‘vector’) ‘"any"’.

  length: a non-negative integer specifying the desired length.  For a
          long vector, i.e., ‘length > .Machine$integer.max’, it has to
          be of type ‘"double"’.  Supplying an argument of length other
          than one is an error.

       x: an R object.

Details:

     The atomic modes are ‘"logical"’, ‘"integer"’, ‘"numeric"’
     (synonym ‘"double"’), ‘"complex"’, ‘"character"’ and ‘"raw"’.

     If ‘mode = "any"’, ‘is.vector’ may return ‘TRUE’ for the atomic
     modes, ‘list’ and ‘expression’.  For any ‘mode’, it will return
     ‘FALSE’ if ‘x’ has any attributes except names.  (This is
     incompatible with S.)  On the other hand, ‘as.vector’ removes
     _all_ attributes including names for results of atomic mode (but
     not those of mode ‘"list"’ nor ‘"expression"’).

     Note that factors are _not_ vectors; ‘is.vector’ returns ‘FALSE’
     and ‘as.vector’ converts a factor to a character vector for ‘mode
     = "any"’.

Value:

     For ‘vector’, a vector of the given length and mode.  Logical
     vector elements are initialized to ‘FALSE’, numeric vector
     elements to ‘0’, character vector elements to ‘""’, raw vector
     elements to ‘nul’ bytes and list/expression elements to ‘NULL’.

     For ‘as.vector’, a vector (atomic or of type list or expression).
     All attributes are removed from the result if it is of an atomic
     mode, but not in general for a list result.  The default method
     handles 24 input types and 12 values of ‘type’: the details of
     most coercions are undocumented and subject to change.

     For ‘is.vector’, ‘TRUE’ or ‘FALSE’.  ‘is.vector(x, mode =
     "numeric")’ can be true for vectors of types ‘"integer"’ or
     ‘"double"’ whereas ‘is.vector(x, mode = "double")’ can only be
     true for those of type ‘"double"’.

Methods for 'as.vector()':

     Writers of methods for ‘as.vector’ need to take care to follow the
     conventions of the default method.  In particular

        ? Argument ‘mode’ can be ‘"any"’, any of the atomic modes,
          ‘"list"’, ‘"expression"’, ‘"symbol"’, ‘"pairlist"’ or one of
          the aliases ‘"double"’ and ‘"name"’.

        ? The return value should be of the appropriate mode.  For
          ‘mode = "any"’ this means an atomic vector or list.

        ? Attributes should be treated appropriately: in particular
          when the result is an atomic vector there should be no
          attributes, not even names.

        ? ‘is.vector(as.vector(x, m), m)’ should be true for any mode
          ‘m’, including the default ‘"any"’.

Note:

     ‘as.vector’ and ‘is.vector’ are quite distinct from the meaning of
     the formal class ‘"vector"’ in the ‘methods’ package, and hence
     ‘as(x, "vector")’ and ‘is(x, "vector")’.

     Note that ‘as.vector(x)’ is not necessarily a null operation if
     ‘is.vector(x)’ is true: any names will be removed from an atomic
     vector.

     Non-vector ‘mode’s ‘"symbol"’ (synonym ‘"name"’) and ‘"pairlist"’
     are accepted but have long been undocumented: they are used to
     implement ‘as.name’ and ‘as.pairlist’, and those functions should
     preferably be used directly.  None of the description here applies
     to those ‘mode’s: see the help for the preferred forms.

References:

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

See Also:

     ‘c’, ‘is.numeric’, ‘is.list’, etc.

Examples:

     df <- data.frame(x = 1:3, y = 5:7)
     ## Error:
     try(as.vector(data.frame(x = 1:3, y = 5:7), mode = "numeric"))
     
     x <- c(a = 1, b = 2)
     is.vector(x)
     as.vector(x)
     all.equal(x, as.vector(x)) ## FALSE
     
     
     ###-- All the following are TRUE:
     is.list(df)
     ! is.vector(df)
     ! is.vector(df, mode = "list")
     
     is.vector(list(), mode = "list")