Various R programming tools for data manipulation

Various R programming tools for data manipulation [R logo]

Help pages for package `gdata' version 2.3.1

"[.levelsMap" | Mapping levels
"[.listLevelsMap" | Mapping levels
.checkLevelsMap | Mapping levels
.checkListLevelsMap | Mapping levels
aggregate.table | Create 2-Way Table of Summary Statistics
Args | Formatted Argument List of a Function
as.levelsMap | Mapping levels
as.listLevelsMap | Mapping levels
c.factor | Combine factors, properly handling levels
c.levelsMap | Mapping levels
c.listLevelsMap | Mapping levels
combine | Combine R Objects With a Column Labeling the Source
ConvertMedUnits | Convert medical measurements between International Standard (SI) and US 'Conventional' Units.
drop.levels | Drop unused factor levels
elem | Display Information about Elements in a Given Object
env | Display Information about All Loaded Environments
frameApply | Subset analysis on data frames
interleave | Interleave Rows of Data Frames or Matrices
is.levelsMap | Mapping levels
is.listLevelsMap | Mapping levels
is.what | Run Multiple is.* Tests on a Given Object
isUnknown | Change unknown values to NA and vice versa
keep | Remove All Objects, Except Those Specified
ll | Display Information about Objects or Elements
lowerTriangle | Extract or replace the upper/lower triangular portion of a matrix
mapLevels | Mapping levels
matchcols | Select columns names matching certain critera
MedUnits | Table of conversions between Intertional Standard (SI) and US 'Conventional' Units for common medical measurements.
NAToUnknown | Change unknown values to NA and vice versa
nobs | Compute the Number of Non-missing Observations
print.levelsMap | Mapping levels
print.listLevelsMap | Mapping levels
read.xls | Read Excel files
remove.vars | Remove or rename variables in a dataframe
rename.vars | Remove or rename variables in a dataframe
reorder.factor | Reorder the Levels of a Factor
resample | Consistent Random Samples and Permutations
sort.levelsMap | Mapping levels
trim | Remove leading and trailing spaces from character strings
unique.levelsMap | Mapping levels
unknownToNA | Change unknown values to NA and vice versa
unmatrix | Convert a matrix into a vector, with appropriate names
upperTriangle | Extract or replace the upper/lower triangular portion of a matrix
write.fwf | Write object in fixed width format


Create 2-Way Table of Summary Statistics

Description

Splits the data into subsets based on two factors, computes a summary statistic on each subset, and arranges the results in a 2-way table.

Usage

aggregate.table(x, by1, by2, FUN=mean, ...)

Arguments

x | data to be summarized
by1 | first grouping factor.
by2 | second grouping factor.
FUN | a scalar function to compute the summary statistics which can be applied to all data subsets. Defaults to mean.
... | Optional arguments for FUN.

Value

Returns a matrix with one element for each combination of by1 and by2.

Author(s)

Gregory R. Warnes warnes@bst.rochester.edu

See Also

aggregate, tapply, interleave

Examples

# Useful example:
#
# Create a 2-way table of means, standard errors, and # obs

g1 <- sample(letters[1:5], 1000, replace=TRUE)
g2 <- sample(LETTERS[1:3], 1000, replace=TRUE )
dat <- rnorm(1000)

stderr <- function(x) sqrt( var(x,na.rm=TRUE) / nobs(x) )

means   <- aggregate.table( dat, g1, g2, mean )
stderrs <- aggregate.table( dat, g1, g2, stderr )
ns      <- aggregate.table( dat, g1, g2, nobs )
blanks <- matrix( " ", nrow=5, ncol=3)

tab <- interleave( "Mean"=round(means,2),
                   "Std Err"=round(stderrs,2),
                   "N"=ns, " " = blanks, sep=" " )

print(tab, quote=FALSE)
[Package gdata version 2.3.1 Index]


Formatted Argument List of a Function

Description

Display function argument names and corresponding default values, formatted in two columns for easy reading.

Usage

Args(name, sort.args = FALSE)

Arguments

name | a function or function name.
sort.args | whether arguments should be sorted.

Value

A data frame with named rows and a single column called value, containing the default value of each argument.

Author(s)

Arni Magnusson arnima@u.washington.edu

See Also

args, formals, help.

Examples

Args(glm)
Args(scan)
Args(legend)


Combine factors, properly handling levels

c.factor(gdata) R Documentation

Combine factors properly handling levels

Description

This method for c combines factors while properly preserves level information.

Usage

c.factor(..., recursive = FALSE)

Arguments

... | factors to be combined
recursive | ignored

Details

Value

A single factor object. The levels on the new object are created by concatinating the levels of the provided factors, with any duplicate level names merged, and with the factor coding modified appropriately.

Author(s)

Gregor Gorjan

See Also

c

Examples

f1 <- factor(letters[1:10])
f2 <- factor(letters[5:14])

c(f1,f2)


Combine R Objects With a Column Labeling the Source

Description

Take a sequence of vector, matrix or data frames and combine into rows of a common data frame with an additional column source indicating the source object.

Usage

combine(..., names=NULL)

Arguments

... | vectors or matrices to combine.
names | character vector of names to use when creating source column.

Details

If there are several matrix arguments, they must all have the same number of columns. The number of columns in the result will be one larger than the number of columns in the component matrixes. If all of the arguments are vectors, these are treated as single column matrixes. In this case, the column containing the combineinated vector data is labeled data.

When the arguments consist of a mix of matrices and vectors the number of columns of the result is determined by the number of columns of the matrix arguments. Vectors are considered row vectors and have their values recycled or subsetted (if necessary) to achieve this length.

The source column is created as a factor with levels corresponding to the name of the object from which the each row was obtained. When the names argument is ommitted, the name of each object is obtained from the specified argument name in the call (if present) or from the name of the object. See below for examples.

Author(s)

Gregory R. Warnes warnes@bst.rochester.edu

See Also

rbind, merge

Examples

a  <-  matrix(rnorm(12),ncol=4,nrow=3)
b  <-  1:4
combine(a,b)

combine(x=a,b)
combine(x=a,y=b)
combine(a,b,names=c("one","two"))

c <- 1:6
combine(b,c)


Convert medical measurements between International Standard (SI) and US 'Conventional' Units.

Description

Convert Medical measurements between International Standard (SI) and US 'Conventional' Units.

Usage

ConvertMedUnits(x, measurement, abbreviation,
                to = c("Conventional", "SI", "US"),
                exact = !missing(abbreviation))

Arguments

x | Vector of measurement values
measurement | Name of the measurement
abbreviation | Measurement abbreviation
to | Target units
exact | Logicial indicating whether matching should be exact

Details

Medical laboratories and practitioners in the United States use one set of units (the so-called 'Conventional' units) for reporting the results of clinical laboratory measurements, while the rest of the world uses the International Standard (SI) units. It often becomes necessary to translate between these units when participating in international collaborations.

This function converts between SI and US 'Conventional' units.

If exact=FALSE, grep will be used to do a case-insensitive sub-string search for matching measurment names. If more than one match is found, an error will be generated, along with a list of the matching entries.

Value

Returns a vector of converted values. The attribute 'units' will contain the target units converted.

Author(s)

Gregory R. Warnes warnes@bst.rochester.edu

References

http://www.globalrph.com/conv_si.htm

See Also

The data set MedUnits provides the conversion factors.

Examples

data(MedUnits)

# show available conversions
MedUnits$Measurement

# Convert SI Glucose measurement to 'Conventional' units
GlucoseSI = c(5, 5.4, 5, 5.1, 5.6, 5.1, 4.9, 5.2, 5.5) # in SI Units
GlucoseUS = ConvertMedUnits( GlucoseSI, "Glucose", to="US" )
cbind(GlucoseSI,GlucoseUS)

## Not run:
# See what happens when there is more than one match
ConvertMedUnits( 27.5, "Creatin", to="US")
## End(Not run)

# To solve the problem do:
ConvertMedUnits( 27.5, "Creatinine", to="US", exact=TRUE)


Drop unused factor levels

Description

Drop unused levels in a factor.

Usage

drop.levels(x, reorder=TRUE, ...)

Arguments

x | object to be processed
reorder | should factor levels be reordered using reorder.factor?
... | additional arguments to reorder.factor

Details

drop.levels is a generic function, where default method does nothing, while method for factor s drops all unused levels. There are also convinient methods for list and data.frame, where all unused levels are droped in all factors (one by one) in a list or a data.frame.

Value

a data frame

Author(s)

Jim Rogers james.a.rogers@pfizer.com

Examples

f <- factor(c("A", "B", "C", "D"))[1:3]
drop.levels(f)

l <- list(f=f, i=1:3, c=c("A", "B", "D"))
drop.levels(l)

df <- as.data.frame(l)
str(df)
str(drop.levels(df))


Display Information about Elements in a Given Object

Description

This function is depreciated. Please use ll instead.

Display name, class, size, and dimensions of each element in a given object.

Usage

elem(object=1, unit=c("KB","MB","bytes"), digits=0,
                 dimensions=FALSE)

Arguments

object | object containing named elements, perhaps a model or data frame.
unit | required unit for displaying element size: "KB", "MB", "bytes", or first letter.
digits | number of decimals to display when rounding element size.
dimensions | whether element dimensions should be returned.

Details

A verbose alternative to names().

Value

A data frame with named rows and the following columns:

Class | element class.
KB | element size (see notes).
Dim | element dimensions (optional).

Note

The name of the element size column is the same as the unit used.

Elements of class classRepresentation, ClassUnionRepresentation, and grob do not have a defined size, so 0 bytes are assumed for those.

Author(s)

Arni Magnusson arnima@u.washington.edu

See Also

names, str, and summary display different information about object elements.

ll and env are related to elem.

Examples

## Not run:
data(infert)
elem(infert)
model <- glm(case~spontaneous+induced, family=binomial, data=infert)
elem(model, dim=TRUE)
elem(model$family)
## End(Not run)


Display Information about All Loaded Environments

Description

Display name, number of objects, and size of all loaded environments.

Usage

env(unit=c("KB","MB","bytes"), digits=0)

Arguments

unit | required unit for displaying environment size: "bytes", "KB", "MB", or first letter.
digits | number of decimals to display when rounding environment size.

Details

A verbose alternative to search().

Value

A data frame with the following columns:

Environment | environment name.
Objects | number of objects in environment.
KB | environment size (see notes).

Note

The name of the environment size column is the same as the unit used.

Author(s)

Arni Magnusson arnima@u.washington.edu

See Also

search displays environment names.

ll is related to env.

Examples

## Not run:
env()
## End(Not run)


Subset analysis on data frames

Description

Apply a function to row subsets of a data frame.

Usage

frameApply(x, by = NULL, on = by[1], fun = function(xi) c(Count =
nrow(xi)), subset = TRUE, simplify = TRUE, byvar.sep = "\$\@\$", ...)

Arguments

x | a data frame
by | names of columns in x specifying the variables to use to form the subgroups. None of the by variables should have the name "sep" (you will get an error if one of them does; a bit of laziness in the code). Unused levels of the by variables will be dropped. Use by = NULL (the default) to indicate that all of the data is to be treated as a single (trivial) subgroup.
on | names of columns in x specifying columns over which fun is to be applied. These can include columns specified in by, (as with the default) although that is not usually the case.
fun | a function that can operate on data frames that are row subsets of x[on]. If simplify = TRUE, the return value of the function should always be either a try-error (see try), or a vector of fixed length (i.e. same length for every subset), preferably with named elements.
subset | logical vector (can be specified in terms of variables in data). This row subset of x is taken before doing anything else.
simplify | logical. If TRUE (the default), return value will be a data frame including the by columns and a column for each element of the return vector of fun. If FALSE, the return value will be a list, sometimes necessary for less structured output (see description of return value below).
byvar.sep | character. This can be any character string not found anywhere in the values of the by variables. The by variables will be pasted together using this as the separator, and the result will be used as the index to form the subgroups.
... | additional arguments to fun.

Details

This function accomplishes something similar to by. The main difference is that frameApply is designed to return data frames and lists instead of objects of class 'by'. Also, frameApply works only on the unique combinations of the by that are actually present in the data, not on the entire cartesian product of the by variables. In some cases this results in great gains in efficiency, although frameApply is hardly an efficient function.

Value

a data frame if simplify = TRUE (the default), assuming there is sufficiently structured output from fun. If simplify = FALSE and by is not NULL, the return value will be a list with two elements. The first element, named "by", will be a data frame with the unique rows of x[by], and the second element, named "result" will be a list where the ith component gives the result for the ith row of the "by" element.

Author(s)

Jim Rogers james.a.rogers@pfizer.com

Examples

data(ELISA, package="gtools")

# Default is slightly unintuitive, but commonly useful:
frameApply(ELISA, by = c("PlateDay", "Read"))

# Wouldn't actually recommend this model! Just a demo:
frameApply(ELISA, on = c("Signal", "Concentration"), by = c("PlateDay", "Read"),
           fun = function(dat) coef(lm(Signal ~ Concentration, data =
dat)))

frameApply(ELISA, on = "Signal", by = "Concentration",
           fun = function(dat, ...) {
                    x <- dat[[1]]
                    out <- c(Mean = mean(x, ...),
                             SD = sd(x, ...),
                             N = sum(!is.na(x)))
                  },
           na.rm = TRUE,
           subset = !is.na(Concentration))


Interleave Rows of Data Frames or Matrices

Description

Interleave rows of data frames or Matrices.

Usage

interleave(..., append.source=TRUE, sep=": ", drop=FALSE)

Arguments

... | objects to be interleaved
append.source | Boolean Flag. When TRUE (the default) the argument name will be appended to the row names to show the source of each row.
sep | Separator between the original row name and the object name.
drop | logical - If the number of columns in output matrix is 1, whether matrix should be returned or a vector

Details

This function creates a new matrix or data frame from its arguments.

The new object will have all of the rows from the source objects interleaved. IE, it will contain row 1 of object 1, followed by row 1 of object 2, .. row 1 of object 'n', row 2 of object 1, row 2 of object 2, ... row 2 of object 'n' ...

Value

Matrix containing the interleaved rows of the function arguments.

Author(s)

Gregory R. Warnes warnes@bst.rochester.edu

See Also

cbind, rbind, combine

Examples

# Simple example
a <- matrix(1:10,ncol=2,byrow=TRUE)
b <- matrix(letters[1:10],ncol=2,byrow=TRUE)
c <- matrix(LETTERS[1:10],ncol=2,byrow=TRUE)
interleave(a,b,c)

# Useful example:
#
# Create a 2-way table of means, standard errors, and # obs

g1 <- sample(letters[1:5], 1000, replace=TRUE)
g2 <- sample(LETTERS[1:3], 1000, replace=TRUE )
dat <- rnorm(1000)

stderr <- function(x) sqrt( var(x,na.rm=TRUE) / nobs(x) )

means   <- aggregate.table( dat, g1, g2, mean )
stderrs <- aggregate.table( dat, g1, g2, stderr )
ns      <- aggregate.table( dat, g1, g2, nobs )
blanks <- matrix( " ", nrow=5, ncol=3)

tab <- interleave( "Mean"=round(means,2),
                   "Std Err"=round(stderrs,2),
                   "N"=ns, " " = blanks, sep=" " )

print(tab, quote=FALSE)

# Using drop to control coercion to a lower dimensions:

m1 <- matrix(1:4)
m2 <- matrix(5:8)

interleave(m1, m2, drop=TRUE)  # This will be coerced to a vector

interleave(m1, m2, drop=FALSE) # This will remain a matrix


Run Multiple is.* Tests on a Given Object

Description

Run multiple is.* tests on a given object, such as is.numeric(), is.list(), ...

Usage

is.what(object, verbose = FALSE)

Arguments

object | any R object.
verbose | whether negative tests should be included in output.

Value

A character vector containing positive tests, or when verbose is TRUE, a data frame showing all test results.

Author(s)

Arni Magnusson arnima@u.washington.edu, inspired by demo(is.things).

See Also

is.na and is.numeric are commonly used tests.

Examples

is.what(pi)
is.what(NA, verbose=TRUE)
is.what(lm(1~1))


Remove All Objects, Except Those Specified

keep(gdata) R Documentation

Remove All Objects Except Those Specified

Description

Remove all objects from the default workspace, except those specified.

Usage

keep(..., list = character(0), sure = FALSE)

Arguments

... | objects to be kept, specified one by one, quoted or unquoted.
list | character vector of object names to be kept.
sure | whether to perform the removal, otherwise return names of objects that would have been removed.

Details

Convenient interface to rm() when removing most objects from the default workspace.

Implemented with a few safety caps: objects whose name starts with a period ‘.’ are not removed, and sure=TRUE is required to perform the removal.

Value

A character vector containing object names, or NULL when sure is TRUE.

Author(s)

Arni Magnusson arnima@u.washington.edu

See Also

rm.

Examples

data(women, cars)
keep(cars)
## To remove all objects except cars, run:
## keep(cars, sure=TRUE)


Display Information about Objects or Elements

Description

Display name, class, size, and dimensions of each object in a given environment. Alternatively, if the main argument is a list-like object, its elements are listed and described.

Usage

ll(pos=1, unit=c("KB","MB","bytes"), digits=0, dimensions=FALSE,
   function.dim="", sort.elements=FALSE, ...)

Arguments

pos | environment position number, environment name, data frame, list, model, or any object that is.list().
unit | required unit for displaying object size: "bytes", "KB", "MB", or first letter.
digits | number of decimals to display when rounding object size.
dimensions | whether object dimensions should be returned.
function.dim | value to report as the dimension of function objects.
sort.elements | whether elements should be sorted by name.
... | passed to ls().

Details

A verbose alternative to ls() and names().

Value

A data frame with named rows and the following columns:

Class | object class.
KB | object size (see notes).
Dim | object dimensions (optional).

Note

The name of the object size column is the same as the unit used.

Author(s)

Arni Magnusson arnima@u.washington.edu, with a contribution by Jim Rogers james.a.rogers@pfizer.com

See Also

ls displays names of objects in a given environment.

names, str, and summary display different information about list-like elements.

env is related to ll.

Examples

ll()
ll(all=TRUE)
ll("package:base")
ll("package:base")[ll("package:base")$Class!="function",]

data(infert)
ll(infert)
model <- glm(case~spontaneous+induced, family=binomial, data=infert)
ll(model, dim=TRUE)
ll(model, sort=TRUE)
ll(model$family)


Mapping levels

Description

mapLevels produces a map with information on levels and/or internal integer codes. As such can be conveniently used to store level mapping when one needs to work with internal codes of a factor and later transfrorm back to factor or when working with several factors that should have the same levels and therefore the same internal coding.

Usage

mapLevels(x, codes=TRUE, sort=TRUE, drop=FALSE, combine=FALSE, ...)
mapLevels(x) <- value

Arguments

x | object whose levels will be mapped, look into details
codes | boolean, create integer levelsMap (with internal codes) or character levelsMap (with level names)
sort | boolean, sort levels of character x, look into details
drop | boolean, drop unused levels
combine | boolean, combine levels, look into details
... | additional arguments for sort
value | levelsMap or listLevelsMap, output of mapLevels methods or constructed by user, look into details

Value

mapLevels() returns “levelsMap” or “listLevelsMap” objects as described in levelsMap and listLevelsMap section.
Result of mapLevels<- is always a factor with remapped levels or a “list/data.frame” with remapped factors.

mapLevels

mapLevels function was written primarly for work with “factors”, but is generic and can also be used with “character”, “list” and “data.frame”, while “default” method produces error. Here the term levels is also used for unique character values.

When codes=TRUE integer “levelsMap” with information on mapping internal codes with levels is produced. Output can be used to transform integer to factor or remap factor levels as described bellow. With codes=FALSE character “levelsMap” is produced. The later is usefull, when one would like to remap factors or combine factors with some overlap in levels as described in mapLevels<- section and shown in examples.

sort argument provides possibility to sort levels of “character” x and has no effect when x is a “factor”.

Argument combine has effect only in “list” and “data.frame” methods and when codes=FALSE i.e. with character “levelsMaps”. The later condition is necesarry as it is not possible to combine maps with different mapping of level names and integer codes. It is assumed that passed “list” and “data.frame” have all components for which methods exist. Otherwise error is produced.

levelsMap and listLevelsMap

Function mapLevels returns a map of levels. This map is of class “levelsMap”, which is actually a list of length equal to number of levels and with each component of length 1. Components need not be of length 1. There can be either integer or character “levelsMap”. Integer “levelsMap” (when codes=TRUE) has names equal to levels and components equal to internal codes. Character “levelsMap” (when codes=FALSE) has names and components equal to levels. When mapLevels is applied to “list” or “data.frame”, result is of class “listLevelsMap”, which is a list of “levelsMap” components described previously. If combine=TRUE, result is a “levelsMap” with all levels in x components.

For ease of inspection, print methods unlists “levelsMap” with proper names. mapLevels<- methods are fairly general and therefore additional convenience methods are implemented to ease the work with maps: is.levelsMap and is.listLevelsMap; as.levelsMap and as.listLevelsMap for coercion of user defined maps; generic "[" and c for both classes (argument recursive can be used in c to coerce “listLevelsMap” to “levelsMap”) and generic unique and sort (generic from R 2.4) for “levelsMap”.

mapLevels<-

Workhorse under mapLevels<- methods is levels<-. mapLevels<- just control the assignment of “levelsMap” (integer or character) or “listLevelsMap” to x. The idea is that map values are changed to map names as indicated in levels examples. Integer “levelsMap” can be applied to “integer” or “factor”, while character “levelsMap” can be applied to “character” or “factor”. Methods for “list” and “data.frame” can work only on mentioned atomic components/columns and can accept either “levelsMap” or “listLevelsMap”. Recycling occurs, if length of value is not the same as number of components/columns of a “list/data.frame”.

Author(s)

Gregor Gorjanc

See Also

factor, levels and unclass

Examples

## --- Integer levelsMap ---

(f <- factor(sample(letters, size=20, replace=TRUE)))
(mapInt <- mapLevels(f))

## Integer to factor
(int <- as.integer(f))
(mapLevels(int) <- mapInt)
all.equal(int, f)

## Remap levels of a factor
(fac <- factor(as.integer(f)))
(mapLevels(fac) <- mapInt) # the same as levels(fac) <- mapInt
all.equal(fac, f)

## --- Character levelesMap ---

f1 <- factor(letters[1:10])
f2 <- factor(letters[5:14])

## Internal codes are the same, but levels are not
as.integer(f1)
as.integer(f2)

## Get character levelsMaps and combine them
mapCha1 <- mapLevels(f1, codes=FALSE)
mapCha2 <- mapLevels(f2, codes=FALSE)
(mapCha <- c(mapCha1, mapCha2))

## Remap factors
mapLevels(f1) <- mapCha # the same as levels(f1) <- mapCha
mapLevels(f2) <- mapCha # the same as levels(f2) <- mapCha

## Internal codes are now "consistent" among factors
as.integer(f1)
as.integer(f2)

## Remap characters to get factors
f1 <- as.character(f1); f2 <- as.character(f2)
mapLevels(f1) <- mapCha
mapLevels(f2) <- mapCha

## Internal codes are now "consistent" among factors
as.integer(f1)
as.integer(f2)


Select columns names matching certain critera

Description

This function allows easy selection of the column names of an object using a set of inclusion and exclusion critera.

Usage

matchcols(object, with, without, method=c("and","or"), ...)

Arguments

object | Matrix or dataframe
with, without | Vector of regular expression patterns
method | One of "and" or "or"
... | Optional arguments to grep

Value

Vector of column names which match all (method="and") or any (method="or") of the patterns specified in with, but none of the patterns specified in without.

Author(s)

Gregory R. Warnes warnes@bst.rochester.edu

See Also

grep

Examples

# create a matrix with a lot of named columns
x <- matrix( ncol=30, nrow=5 )
colnames(x) <- c("AffyID","Overall Group Means: Control",
                     "Overall Group Means: Moderate",
                     "Overall Group Means: Marked",
                     "Overall Group Means: Severe",
                     "Overall Group StdDev: Control",
                     "Overall Group StdDev: Moderate",
                     "Overall Group StdDev: Marked",
                     "Overall Group StdDev: Severe",
                     "Overall Group CV: Control",
                     "Overall Group CV: Moderate",
                     "Overall Group CV: Marked",
                     "Overall Group CV: Severe",
                     "Overall Model P-value",
                     "Overall Model: (Intercept): Estimate",
                     "Overall Model: Moderate: Estimate",
                     "Overall Model: Marked: Estimate",
                     "Overall Model: Severe: Estimate",
                     "Overall Model: (Intercept): Std. Error",
                     "Overall Model: Moderate: Std. Error",
                     "Overall Model: Marked: Std. Error",
                     "Overall Model: Severe: Std. Error",
                     "Overall Model: (Intercept): t value",
                     "Overall Model: Moderate: t value",
                     "Overall Model: Marked: t value",
                     "Overall Model: Severe: t value",
                     "Overall Model: (Intercept): Pr(>|t|)",
                     "Overall Model: Moderate: Pr(>|t|)",
                     "Overall Model: Marked: Pr(>|t|)",
                     "Overall Model: Severe: Pr(>|t|)")

# Get the columns which give estimates or p-values
# only for marked and severe groups
matchcols(x, with=c("Pr", "Std. Error"),
             without=c("Intercept","Moderate"),
             method="or"
          )

# Get just the column which give the p-value for the intercept
matchcols(x, with=c("Intercept", "Pr") )


Table of conversions between Intertional Standard (SI) and US 'Conventional' Units for common medical measurements.

Description

Table of conversions between Intertional Standard (SI) and US 'Conventional' Units for common medical measurements.

Usage

data(MedUnits)

Format

A data frame with the following 5 variables.

Abbreviation
Common Abbreviation (mostly missing)
Measurement
Measurement Name
SIUnit
SI Unit
Conversion
Conversion factor
ConvetionalUnit
Conventional Unit

Details

Medical laboratories and practitioners in the United States use one set of units (the so-called 'Conventional' units) for reporting the results of clinical laboratory measurements, while the rest of the world uses the International Standard (SI) units. It often becomes necessary to translate between these units when participating in international collaborations.

This data set provides constants for converting between SI and US 'Conventional' units.

To perform the conversion from SI units to US 'Conventional' units do:

Measurement in ConventionalUnit = (Measurement in SIUnit) / Conversion

To perform conversion from 'Conventional' to SI units do:

Measurement in SIUnit = (Measurement in ConventionalUnit) * Conversion

Source

http://www.globalrph.com/conv_si.htm

See Also

The function ConvertMedUnits automates the conversion task.

Examples

data(MedUnits)

# show available conversions
MedUnits$Measurement

# utility function
matchUnits <- function(X) MedUnits[ grep(X, MedUnits$Measurement),]

# Convert SI Glucose measurement to 'Conventional' units
GlucoseSI = c(5, 5.4, 5, 5.1, 5.6, 5.1, 4.9, 5.2, 5.5) # in SI Units
GlucoseUS = GlucoseSI / matchUnits("Glucose")$Conversion
cbind(GlucoseSI,GlucoseUS)

# also consider using ConvertMedUnits()
ConvertMedUnits( GlucoseSI, "Glucose", to="US" )


Compute the Number of Non-missing Observations

Description

Compute the number of non-missing observations. Special methods exist for data frames, and lm objects.

Usage

nobs(x, ...)
## Default S3 method:
nobs(x, ...)
## S3 method for class 'data.frame':
nobs(x, ...)
## S3 method for class 'lm':
nobs(x, ...)

Arguments

x | Target Object
... | Optional parameters (currently ignored)

Details

In the simplest case, this is really just wrapper code for sum(!is.na(x)).

Value

A single numeric value or a vector of values (for data.frames) giving the number of non-missing values.

Author(s)

Gregory R. Warnes warnes@bst.rochester.edu

See Also

is.na, length

Examples

x <- c(1,2,3,5,NA,6,7,1,NA )
length(x)
nobs(x)

df <- data.frame(x=rnorm(100), y=rnorm(100))
df[1,1] <- NA
df[1,2] <- NA
df[2,1] <- NA

nobs(df)


Read Excel files

Description

Reads a Microsoft Excel file into a data frame

Usage

read.xls(xls, sheet=1, verbose=FALSE, ..., perl="perl")

Arguments

xls | name of the Microsoft Excel file
sheet | number of sheet within the Excel file from which data are to be read
verbose | logical flag indicating whether details should be printed as the file is processed.
perl | name of the perl executable to be called.
... | additional arguments to read.table. The defaults of read.csv are used.

Details

This function works translating the named Microsoft Excel file into a temporary .csv file, using Greg Warnes' xls2csv Perl script (installed as part of the gregmisc package).

Caution: In the conversion to csv, strings will be quoted. This can be problem if you are trying to use the comment.char option of read.table since the first character of all lines (including comment lines) will be """ after conversion.

Value

a data frame

Note

Either a working version of Perl must be present in the executable search path, or the exact path of the perl executable must be provided via the perl argument. See the examples below for an illustration.

Author(s)

Jim Rogers james.a.rogers@pfizer.com, modified and extended by Gregory R. Warnes warnes@bst.rochester.edu.

References

http://www.analytics.washington.edu/statcomp/downloads/xls2csv

See Also

read.csv

Examples

   # iris.xls is included in the gregmisc package for use as an example
   xlsfile <- file.path(.path.package('gdata'),'xls','iris.xls')
   xlsfile

   iris <- read.xls(xlsfile)
   head(iris)  # look at the top few rows

  ## Not run:
   # Example specifying exact Perl path for default MS-Windows install of
   # ActiveState perl
   iris <- read.xls(xlsfile, perl="C:\perl\bin\perl.exe")

   # Example specifying exact Perl path for Unix systems
   iris <- read.xls(xlsfile, perl="/usr/bin/perl")
   ## End(Not run)


Remove or rename variables in a dataframe

Description

Remove or rename a variables in a data frame.

Usage

rename.vars(data, from="", to="", info=TRUE)
remove.vars(data, names="", info=TRUE)

Arguments

data | dataframe to be modified.
from | character vector containing the current name of each variable to be renamed.
to | character vector containing the new name of each variable to be renamed.
names | character vector containing the names of variables to be removed.
info | boolean value indicating whether to print details of the removal/renaming. Defaults to TRUE.

Value

The updated data frame with variables listed in from renamed to the corresponding element of to.

Author(s)

Code by Don MacQueen macq@llnl.gov. Documentation by Gregory R. Warnes warnes@bst.rochester.edu

See Also

names, colnames, data.frame

Examples

data <- data.frame(x=1:10,y=1:10,z=1:10)
names(data)
data <- rename.vars(data, c("x","y","z"), c("first","second","third"))
names(data)

data <- remove.vars(data, "second")
names(data)


Reorder the Levels of a Factor

Description

Reorder the levels of a factor

Usage

## S3 method for class 'factor':
reorder(x,
                         X,
                         FUN,
                         ...,
                         order=is.ordered(x),
                         new.order,
                         sort=mixedsort)

Arguments

x | factor
X | auxillary data vector
FUN | function to be applied to subsets of X determined by x, to determine factor order
... | optional parameters to FUN
order | logical value indicating whether the returned object should be an ordered factor
new.order | a vector of indexes or a vector of label names giving the order of the new factor levels
sort | function to use to sort the factor level names, used only when new.order is missing

Details

This function changes the order of the levels of a factor. It can do so via three different mechanisms, depending on whether, X and FUN, new.order or sort are provided.

If X and Fun are provided: The data in X is grouped by the levels of x and FUN is applied. The groups are then sorted by this value, and the resulting order is used for the new factor level names.

If new.order is provided: For a numeric vector, the new factor level names are constructed by reordering the factor levels according to the numeric values. For vectors, new.order gives the list of new factor level names. In either case levels omitted from new.order will become missing (NA) values.

If sort is provided (as it is by default): The new factor level names are generated by applying the supplied function to the existing factor level names. With sort=mixedsort the factor levels are sorted so that combined numeric and character strings are sorted in according to character rules on the character sections (including ignoring case), and the numeric rules for the numeric sections. See mixedsort for details.

Value

A new factor with reordered levels

Author(s)

Gregory R. Warnes warnes@bst.rochester.edu

See Also

factor and reorder

Examples

   # Create a 4 level example factor
   trt <- factor( sample( c("PLACEBO", "300 MG", "600 MG", "1200 MG"),
                  100, replace=TRUE ) )
   summary(trt)
   # Note that the levels are not in a meaningful order.

   # Change the order to something useful
   # default "mixedsort" ordering
   trt2 <- reorder(trt)
   summary(trt2)
   # using indexes:
   trt3 <- reorder(trt, new.order=c(4, 2, 3, 1))
   summary(trt3)
   # using label names:
   trt4 <- reorder(trt, new.order=c("PLACEBO", "300 MG", "600 MG", "1200 MG"))
   summary(trt4)
   # using frequency
   trt5 <- reorder(trt, X=as.numeric(trt), FUN=length)
   summary(trt5)

   # drop out the '300 MG' level
   trt6 <- reorder(trt, new.order=c("PLACEBO", "600 MG", "1200 MG"))
   summary(trt6)


Consistent Random Samples and Permutations

Description

resample takes a sample of the specified size from the elements of x using either with or without replacement.

Usage

resample(x, size, replace = FALSE, prob = NULL)

Arguments

x | A numeric, complex, character or logical vector from which to choose.
size | Non-negative integer giving the number of items to choose.
replace | Should sampling be with replacement?
prob | A vector of probability weights for obtaining the elements of the vector being sampled.

Details

resample differs from the S/R sample function in resample always considers x to be a vector of elements to select from, while sample treats a vector of length one as a special case and samples from 1:x. Otherwise, the functions have identical behavior.

Value

~Describe the value returned If it is a LIST, use

comp1 | Description of 'comp1'
comp2 | Description of 'comp2'

...

Warning

....

Note

~~further notes~~

~Make other sections like Warning with section{Warning }{....} ~

Author(s)

~~who you are~~

References

~put references to the literature/web site here ~

See Also

~~objects to See Also as help, ~~~

Examples

##---- Should be DIRECTLY executable !! ----
##-- ==>  Define data, use random,
##--    or do  help(data=index)  for the standard data sets.

## The function is currently defined as
function(x, n, ...)
  {
    if(length(x)==1)
      {
        if(n==1)
          x
        else
          stop("Requested sample of size ", n, " from list of length 1")
      }
    else
      sample(x, n, ...)
  }


Remove leading and trailing spaces from character strings

Description

Remove leading and trailing spaces from character strings and other related objects.

Usage

trim(s, recode.factor=TRUE, ...)

Arguments

s | object to be processed
recode.factor | should levels of a factor be recoded, see below
... | arguments passed to other methods, currently only to reorder.factor for factors

Details

trim is a generic function, where default method does nothing, while method for character s trims its elements and method for factor s trims levels. There are also methods for list and data.frame.

Trimming character strings can change the sort order in some locales. For factors, this can affect the coding of levels. By default, factor levels are recoded to match the trimmed sort order, but this can be disabled by setting recode.factor=FALSE. Recoding is done with reorder.factor.

Value

s with all leading and trailing spaces removed in its elements.

Author(s)

Gregory R. Warnes warnes@bst.rochester.edu with contributions by Gregor Gorjanc

See Also

sub, gsub as well as argument strip.white in read.table and reorder.factor

Examples

s <- "    this is an example string    "
trim(s)

f <- factor(c(s, s, " A", " B ", "  C ", "D "))
levels(f)

trim(f)
levels(trim(f))

trim(f, recode.factor=FALSE)
levels(trim(f, recode.factor=FALSE))

l <- list(s=rep(s, times=6), f=f, i=1:6)
trim(l)

df <- as.data.frame(l)
trim(df)


Change unknown values to NA and vice versa

Description

Unknown or missing values (NA in R) can be represented in various ways (as 0, 999, etc.) in different programs. isUnknown, unknownToNA, and NAToUnknown can help to change unknown values to NA and vice versa.

Usage

isUnknown(x, unknown=NA, ...)
unknownToNA(x, unknown, warning=FALSE, ...)
NAToUnknown(x, unknown, force=FALSE, call.=FALSE, ...)

Arguments

x | generic, object with NA
unknown | generic, value used instead of NA
warning | logical, issue warning if x already has NA
force | logical, force to apply already existing value in x
... | arguments pased to other methods (as.character for POSIXlt in case of isUnknown)
call. | logical, look in warning

Details

This functions were written to handle different variants of “other NA” like representations that are usually used in various external data sources. unknownToNA can help to change unknown values to NA for work in R, while NAToUnknown is meant for the opposite and would usually be used prior to export of data from R. isUnknown is utility function for testing for unknown values.

All functions are generic and the following classes were tested to work with latest version: “integer”, “numeric”, “character”, “factor”, “Date”, “POSIXct”, “POSIXlt”, “list”, “data.frame” and “matrix”. For others default method might work just fine.

unknownToNA and isUnknown can cope with multiple values in unknown, but those should be given as a “vector”. If not, coercing to vector is applied. Argument unknown can be feed also with “list” in “list” and “data.frame” methods.

If named “list” or “vector” is passed to argument unknown and x is also named, matching of names will occur.

Recycling occurs in all “list” and “data.frame” methods, when unknown argument is not of the same length as x and unknown is not named.

Argument unknown in NAToUnknown should hold value that is not already present in x. If it does, error is produced and one can bypass that with force=TRUE, but be warned that there is no way to distinguish values after this action. Use at your own risk! Anyway, warning is issued about new value in x. Additionally, caution should be taken when using NAToUnknown on factors as additional level (value of unknown) is introduced. Then, as expected, unknownToNA removes defined level in unknown. If unknown="NA", then "NA" is removed from factor levels in unknownToNA due to consistency with conversions back and forth.

Unknown representation in unknown should have the same class as x in NAToUnknown, except in factors, where unknown value is coerced to character anyway. Silent coercing is also applied, when “integer” and “numeric” are in question. Otherwise warning is issued and coercing is tried. If that fails, R introduces NA and the goal of NAToUnknown is not reached.

NAToUnknown accepts only single value in unknown if x is atomic, while “list” and “data.frame” methods accept also “vector” and “list”.

“list/data.frame” methods can work on many components/columns. To reduce the number of needed specifications in unknown argument, default unknown value can be specified with component ".default". This matches component/column ".default" as well as all other undefined components/columns! Look in examples.

Value

unknownToNA and NAToUnknown return modified x. isUnknown returns logical values for object x.

Author(s)

Gregor Gorjanc

See Also

is.na

Examples

xInt <- c(0, 1, 0, 5, 6, 7, 8, 9, NA)
isUnknown(x=xInt, unknown=0)
isUnknown(x=xInt, unknown=c(0, NA))
(xInt <- unknownToNA(x=xInt, unknown=0))
(xInt <- NAToUnknown(x=xInt, unknown=0))

xFac <- factor(c("0", 1, 2, 3, NA, "NA"))
isUnknown(x=xFac, unknown=0)
isUnknown(x=xFac, unknown=c(0, NA))
isUnknown(x=xFac, unknown=c(0, "NA"))
isUnknown(x=xFac, unknown=c(0, "NA", NA))
(xFac <- unknownToNA(x=xFac, unknown="NA"))
(xFac <- NAToUnknown(x=xFac, unknown="NA"))

xList <- list(xFac=xFac, xInt=xInt)
isUnknown(xList, unknown=c("NA", 0))
isUnknown(xList, unknown=list("NA", 0))
tmp <- c(0, "NA")
names(tmp) <- c(".default", "xFac")
isUnknown(xList, unknown=tmp)
tmp <- list(.default=0, xFac="NA")
isUnknown(xList, unknown=tmp)

(xList <- unknownToNA(xList, unknown=tmp))
(xList <- NAToUnknown(xList, unknown=999))


Convert a matrix into a vector, with appropriate names

unmatrix(gdata) R Documentation

Convert a matrix into a vector with appropriate names

Description

Convert a matrix into a vector, with element names constructed from the row and column names of the matrix.

Usage

unmatrix(x, byrow=FALSE)

Arguments

x | matrix
byrow | Logical. If FALSE, the elements within columns will be adjacent in the resulting vector, otherwise elements within rows will be adjacent.

Value

A vector with names constructed from the row and column names from the matrix. If the the row or column names are missing, ('r1', 'r2', ..,) or ('c1', 'c2', ..) will be used as appropriate.

Author(s)

Gregory R. Warnes warnes@bst.rochester.edu

See Also

as.vector

Examples

# simple, useless example
m <- matrix( letters[1:10], ncol=5)
m
unmatrix(m)

# unroll model output
x <- rnorm(100)
y <- rnorm(100, mean=3+5*x, sd=0.25)
m <- coef( summary(lm( y ~ x )) )
unmatrix(m)


Extract or replace the upper/lower triangular portion of a matrix

Description

Extract or replace the upper/lower triangular portion of a matrix

Usage

upperTriangle(x, diag=FALSE)
upperTriangle(x, diag=FALSE) <- value
lowerTriangle(x, diag=FALSE)
lowerTriangle(x, diag=FALSE) <- value

Arguments

x | Matrix
diag | Logical. If code{TRUE}, include the matrix diagonal.
value | Either a single value or a vector of length equal to that of the current upper/lower triangular. Should be of a mode which can be coerced to that of x.

Value

upperTriangle(x) and lowerTriangle(x) return the upper or lower triangle of matrix x, respectively. The assignment forms replace the upper or lower traingular area of the matrix with the provided value(s).

Author(s)

Gregory R. Warnes warnes@bst.rochester.edu

See Also

diag

Examples

  x <- matrix( 1:25, nrow=5, ncol=5)
  x
  upperTriangle(x)
  upperTriangle(x, diag=TRUE)

  lowerTriangle(x)
  lowerTriangle(x, diag=TRUE)

  upperTriangle(x) <- NA
  x

  upperTriangle(x, diag=TRUE) <- 1:15
  x

  lowerTriangle(x) <- NA
  x

  lowerTriangle(x, diag=TRUE) <- 1:15
  x


Write object in fixed width format

Description

write.fwf writes object in *f*ixed *w*idth *f*ormat.

Usage

write.fwf(x, file="", append=FALSE, quote=FALSE, sep=" ", na="",
  rownames=FALSE, colnames=TRUE, rowCol=NULL, justify="right",
  formatInfo=FALSE, quoteInfo=TRUE, ...)

Arguments

x | data.frame or matrix, the object to be written
file | character, name of file or connection, look in write.table for more
append | logical, append to existing data in file
quote | logical, quote data in output
na | character, the string to use for missing values i.e. NA in the output
sep | character, separator between columns in output
rownames | logical, print row names
colnames | logical, print column names
rowCol | character, rownames column name
justify | character, allignment of character columns
formatInfo | logical, return information on number of levels, widths and format
quoteInfo | logical, should formatInfo account for quotes
... | further arguments to format.info, format and write.table

Details

Output is similar to print(x) or format(x). Formating is done completely by format on a column basis. Columns in the output are by default separated with a space i.e. empty column with a width of one character, but that can be changed with sep argument as passed to write.table via ....

quote can be used to quote fields in the output. Since all columns of x are converted to character during the output, all columns will be quoted! The following is needed for read.fwf or any other tools outside R. If quotes are used, read.table can be easily used to read the data back into R. Check examples. Do read details on quoteInfo.

Use only *true* character i.e. not "t" or similar for sep as number of characters in sep is needed internally.

Use na to convert missing/unknown values. Only single value can be specified. Take a look at NAToUnknown if you need greater flexibility.

If rowCol is not NULL and rownames=TRUE rownames will also have column name with rowCol value. This is mainly for flexibility with tools outside R. Note that (at least in R 2.4.0) it is not "easy" to import data back to R with read.fwf if you also export rownames. That is the reason, that default is rownames=FALSE.

Information about format of output can be returned if formatInfo=TRUE. Returned value is described in value section. Result is provided by format.info and care was taken to handle numeric properly. If output contains rownames, returned value accounts for this. Additionally, if rowCol is not NULL then returned value contains also information about format of rownames.

If quote=TRUE output is wider due to quotes. Return value (with formatInfo=TRUE) can account for this in two ways; controlled with argument quoteInfo. However, note that there is no way to properly read data back to R if quote=TRUE & quoteInfo=FALSE was specifed for export. quoteInfo applies only when quote=TRUE. Assume there is a file with quoted data as shown bellow (column numbers in first three line are only for demonstration of the values in the output).

123456789 12345678 # for position
123 1234567 123456 # for width with quoteInfo=TRUE
 1   12345   1234  # for width with quoteInfo=FALSE
"a" "hsgdh" "   9"
" " "   bb" " 123"

With quoteInfo=TRUE write.fwf will return (symbolically)

colname position width
V1             1     3
V2             5     7
V3            13     6

or (with quoteInfo=FALSE)

colname position width
V1             2     1
V2             6     5
V3            14     4

Value

Besides its effect to write/export data write.fwf can provide information on format and width. A data.frame is returned with the following columns:

colname | name of the column
nlevels | number of unique values (unused levels of factors are dropped), 0 for numeric column
position | starting column number in the output
width | width of the column
digits | number of digits after the decimal point
exp | width of exponent in exponential representation; 0 means there is no exponential representation, while 1 represents exponent of length one i.e. 1e+6 and 2 1e+06 or 1e+16

Author(s)

Gregor Gorjanc

See Also

format.info, format, NAToUnknown, write.table, read.fwf, read.table and trim

Examples

  ## Some data
  testData <- data.frame(num1=c(1:10, NA),
                         num2=c(NA, seq(from=1, to=5.5, by=0.5)),
                         num3=c(NA, rnorm(n=10, mean=1e6, sd=3e5)),
                         int1=c(as.integer(1:4), NA, as.integer(5:10)),
                         fac1=factor(c(NA, letters[1:10])),
                         fac2=factor(c(letters[6:15], NA)),
                         cha1=c(letters[17:26], NA),
                         cha2=c(NA, letters[26:17]),
                         stringsAsFactors=FALSE)
  levels(testData$fac1) <- c(levels(testData$fac1), "unusedLevel")
  testData$Date <- as.Date("1900-1-1")
  testData$Date[2] <- NA
  testData$POSIXt <- as.POSIXct(strptime("1900-1-1 01:01:01",
                                         format="%Y-%m-%d %H:%M:%S"))
  testData$POSIXt[5] <- NA

  ## Default
  write.fwf(x=testData)

  ## NA should be - or ------------
  write.fwf(x=testData, na="-")
  write.fwf(x=testData, na="------------")

  ## Some other separator than space
  write.fwf(x=testData[, 1:4], sep="-mySep-")

  ## Write to file and report format and fixed width information
  file <- tempfile("test.txt")
  formatInfo <- write.fwf(x=testData, file=file, formatInfo=TRUE)

  ## Read exported data back to R (note +1 due to separator)
  ## ... without header
  read.fwf(file=file, widths=formatInfo$width + 1, header=FALSE, skip=1,
           strip.white=TRUE)

  ## ... with header - via postimport modfication
  tmp <- read.fwf(file=file, widths=formatInfo$width + 1, skip=1,
                  strip.white=TRUE)
  colnames(tmp) <- read.table(file=file, nrow=1, as.is=TRUE)
  tmp

  ## ... with header - persuading read.fwf to accept header properly
  ## (thanks to Marc Schwartz)
  read.fwf(file=file, widths=formatInfo$width + 1, strip.white=TRUE,
           skip=1, col.names=read.table(file=file, nrow=1, as.is=TRUE))

  ## ... with header - with the use of quotes
  write.fwf(x=testData, file=file, quote=TRUE)
  read.table(file=file, header=TRUE, strip.white=TRUE)

  ## Tidy up
  unlink(file)