type.convert {utils} | R Documentation

## Convert Data to Appropriate Type

### Description

Convert a data object to logical, integer, numeric, complex, character or factor as appropriate.

### Usage

    type.convert(x, ...)
    ## Default S3 method:
    type.convert(x, na.strings = "NA", as.is = FALSE, dec = ".",
                 numerals = c("allow.loss", "warn.loss", "no.loss"), ...)
    ## S3 method for class 'data.frame'
    type.convert(x, ...)
    ## S3 method for class 'list'
    type.convert(x, ...)

### Arguments

`x` | a vector, matrix, array, data frame, or list.
`na.strings` | a vector of strings which are to be interpreted as `NA` values. Blank fields are also considered to be missing values in logical, integer, numeric or complex vectors.
`as.is` | whether to convert factors to character vectors. The default is to convert character vectors to factors. See ‘Details’.
`dec` | the character to be assumed for decimal points.
`numerals` | string indicating how to convert numbers whose conversion to double precision would lose accuracy, typically when `x` has more digits than can be stored in a `double`. Can be abbreviated. Possible values are `numerals = "allow.loss"`, default: the conversion happens with some accuracy loss. This was the behavior of R versions 3.0.3 and earlier, and the default from 3.1.1 onwards. `numerals = "warn.loss"`: a `warning` about accuracy loss is signalled and the conversion happens as with `numerals = "allow.loss"`. `numerals = "no.loss"`: `x` is not converted to a number, but to a `factor` or `character`, depending on `as.is`. This was the behavior of R version 3.1.0.
`...` | arguments to be passed to or from methods.

### Details

This helper function is used by `read.table`. When the data object `x` is a data frame or list, the function is called recursively for each column or list element.

Given a vector, the function attempts to convert it to logical, integer, numeric or complex, and failing that converts a character vector to factor unless `as.is = TRUE`. The first type that can accept all the non-missing values is chosen.

Vectors which are entirely missing values are converted to logical, since `NA` is primarily logical.

Vectors containing just `F`, `T`, `FALSE`, `TRUE` and values from `na.strings` are converted to logical. Vectors containing optional whitespace followed by decimal constants representable as R integers or values from `na.strings` are converted to integer. Other vectors containing optional whitespace followed by other decimal or hexadecimal constants (see NumericConstants), or `NaN`, `Inf` or `infinity` (ignoring case) or values from `na.strings` are converted to numeric. Where converting inputs to numeric or complex would result in loss of accuracy they can optionally be returned as strings (for `as.is = TRUE`) or factors.

Since this is a helper function, the caller should always pass an appropriate value of `as.is`.

### Value

An object like `x` but using another storage mode when appropriate.

### Author(s)

R Core, with a contribution by Arni Magnusson

### See Also

`read.table`, `class`, `storage.mode`.

### Examples

    ## Numeric to integer
    class(rivers)
    x <- type.convert(rivers)
    class(x)

    ## Convert many columns
    auto <- type.convert(mtcars)
    str(mtcars)
    str(auto)

    ## Convert matrix
    phones <- type.convert(WorldPhones)
    storage.mode(WorldPhones)
    storage.mode(phones)

    ## Factor or character
    chr <- c("A", "B", "B", "A")
    fac <- factor(c("A", "B", "B", "A"))
    type.convert(chr)               # -> factor
    type.convert(fac)               # -> factor
    type.convert(chr, as.is = TRUE) # -> character
    type.convert(fac, as.is = TRUE) # -> character

[Package utils version 3.5.1 Index]