cbind {base} | R Documentation |

Take a sequence of vector, matrix or>`...`

Combine R Objects by Rows or Columns Description. Take a sequence of vector, matrix or data-frame arguments and combine by columns or rows, respectively. These are generic functions with methods for other R classes. Merging Data Adding Columns. To merge two data frames (datasets) horizontally, use the merge function. In most cases, you join two data frames by one. Combine acs Objects by Rows Description. Take a pair of acs objects and combine by rows. Usage ## S3 method for class 'acs' rbind(e1, e2.) Arguments. Combine rows and sum their values. Ask Question Asked 7 years, 11 months ago. Active 7 years, 11 months ago. Viewed 26k times 8. Below there is a fraction of my. One base R way to do this is with the merge function, using the basic syntax merge(df1, df2). It doesn’t matter the order of data frame 1 and data frame 2, but whichever one is first is.

(generalized) vectors or matrices. These can be given as namedarguments. Other **R** objects may be coerced as appropriate, or S4methods may be used: see sections ‘Details’ and‘Value’. (For the `'data.frame'`

method of `cbind`

these can be further arguments to `data.frame`

such as`stringsAsFactors`

.)

`deparse.level`

integer controlling the construction of labels inthe case of non-matrix-like arguments (for the default method):`deparse.level = 0`

constructs no labels; the default,`deparse.level = 1 or 2`

constructs labels from the argumentnames, see the ‘Value’ section below.

`make.row.names`

(only for data frame method:) logicalindicating if unique and valid `row.names`

should beconstructed from the arguments.

`stringsAsFactors`

logical, passed to `as.data.frame`

;only has an effect when the `...`

arguments contain a(non-`data.frame`

) `character`

.

The functions `cbind`

and `rbind`

are S3 generic, withmethods for data frames. The data frame method will be used if atleast one argument is a data frame and the rest are vectors ormatrices. There can be other methods; in particular, there is one fortime series objects. See the section on ‘Dispatch’ for howthe method to be used is selected. If some of the arguments are of anS4 class, i.e., `isS4(.)`

is true, S4 methods are soughtalso, and the hidden `cbind`

/ `rbind`

functionsfrom package methods maybe called, which in turn build on`cbind2`

or `rbind2`

, respectively. In thatcase, `deparse.level`

is obeyed, similarly to the default method.

In the default method, all the vectors/matrices must be atomic (see`vector`

) or lists. Expressions are not allowed.Language objects (such as formulae and calls) and pairlists will becoerced to lists: other objects (such as names and external pointers)will be included as elements in a list result. Any classes the inputsmight have are discarded (in particular, factors are replaced by theirinternal codes).

If there are several matrix arguments, they must all have the samenumber of columns (or rows) and this will be the number of columns (orrows) of the result. If all the arguments are vectors, the number ofcolumns (rows) in the result is equal to the length of the longestvector. Values in shorter arguments are recycled to achieve thislength (with a `warning`

if they are recycled only*fractionally*).

When the arguments consist of a mix of matrices and vectors the numberof columns (rows) of the result is determined by the number of columns(rows) of the matrix arguments. Any vectors have their valuesrecycled or subsetted to achieve this length.

For `cbind`

(`rbind`

), vectors of zero length (including`NULL`

) are ignored unless the result would have zero rows(columns), for S compatibility.(Zero-extent matrices do not occur in S3 and are not ignored in **R**.)

Matrices are restricted to less than *2^31* rows andcolumns even on 64-bit systems. So input vectors have the same lengthrestriction: as from **R** 3.2.0 input matrices with more elements (butmeeting the row and column restrictions) are allowed.

For the default method, a matrix combining the `...`

argumentscolumn-wise or row-wise. (Exception: if there are no inputs or allthe inputs are `NULL`

, the value is `NULL`

.)

The type of a matrix result determined from the highest type of any ofthe inputs in the hierarchy raw < logical < integer < double < complex <character < list .

For `cbind`

(`rbind`

) the column (row) names are taken fromthe `colnames`

(`rownames`

) of the arguments if these arematrix-like. Otherwise from the names of the arguments or where thoseare not supplied and `deparse.level > 0`

, by deparsing theexpressions given, for `deparse.level = 1`

only if that gives asensible name (a ‘symbol’, see `is.symbol`

).

For `cbind`

row names are taken from the first argument withappropriate names: rownames for a matrix, or names for a vector oflength the number of rows of the result.

For `rbind`

column names are taken from the first argument withappropriate names: colnames for a matrix, or names for a vector oflength the number of columns of the result.

The `cbind`

data frame method is just a wrapper for`data.frame(..., check.names = FALSE)`

. This means thatit will split matrix columns in data frame arguments, and convertcharacter columns to factors unless `stringsAsFactors = FALSE`

isspecified.

The `rbind`

data frame method first drops all zero-column andzero-row arguments. (If that leaves none, it returns the firstargument with columns otherwise a zero-column zero-row data frame.)It then takes the classes of the columns from thefirst data frame, and matches columns by name (rather than byposition). Factors have their levels expanded as necessary (in theorder of the levels of the levelsets of the factors encountered) andthe result is an ordered factor if and only if all the components wereordered factors. (The last point differs from S-PLUS.) Old-stylecategories (integer vectors with levels) are promoted to factors.

The method dispatching is *not* done via`UseMethod()`

, but by C-internal dispatching.Therefore there is no need for, e.g., `rbind.default`

.

The dispatch algorithm is described in the source file(‘.../src/main/bind.c’) as

For each argument we get the list of possible classmemberships from the class attribute.

We inspect each class in turn to see if there is anapplicable method.

If we find an applicable method we make sure that it isidentical to any method determined for prior arguments.If it is identical, we proceed, otherwise we immediatelydrop through to the default code.

If you want to combine other objects with data frames, it may benecessary to coerce them to data frames first. (Note that thisalgorithm can result in calling the data frame method if all thearguments are either data frames or vectors, and this will result inthe coercion of character vectors to factors.)

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

`c`

to combine vectors (and lists) as vectors,`data.frame`

to combine vectors and matrices as a dataframe.

Coments are closed