intubate (version 1.0.0)

stats: Interfaces for stats package for data science pipelines.

Description

Interfaces to stats functions that can be used in a pipeline implemented by magrittr.

Usage

ntbt_aggregate(data, ...)
ntbt_alias(data, ...)
ntbt_ansari.test(data, ...)
ntbt_aov(data, ...)
ntbt_bartlett.test(data, ...)
ntbt_cor.test(data, ...)
ntbt_fligner.test(data, ...)
ntbt_friedman.test(data, ...)
ntbt_ftable(data, ...)
ntbt_getInitial(data, ...)
ntbt_glm(data, ...)
ntbt_kruskal.test(data, ...)
ntbt_lm(data, ...)
ntbt_loess(data, ...)
ntbt_lqs(data, ...)
ntbt_model.frame(data, ...)
ntbt_model.matrix(data, ...)
ntbt_mood.test(data, ...)
ntbt_nls(data, ...)
ntbt_oneway.test(data, ...)
ntbt_ppr(data, ...)
ntbt_prcomp(data, ...)
ntbt_princomp(data, ...)
ntbt_quade.test(data, ...)
ntbt_replications(data, ...)
ntbt_t.test(data, ...)
ntbt_var.test(data, ...)
ntbt_wilcox.test(data, ...)
ntbt_xtabs(data, ...)

Arguments

data

data frame, tibble, list, ...

...

Other arguments passed to the corresponding interfaced function.

Value

Object returned by interfaced function.

Details

Interfaces call their corresponding interfaced function.

Examples

## Not run: 
# library(intubate)
# library(magrittr)
# 
# ## aggregate
# ## Original function to interface
# ag <- aggregate(len ~ ., data = ToothGrowth, mean)
# xtabs(len ~ ., data = ag)
# 
# ## The interface reverses the order of data and formula
# ag <- ntbt_aggregate(ToothGrowth, len ~ ., mean)
# ntbt_xtabs(ag, len ~ .)
# 
# ## so it can be used easily in a pipeline.
# ToothGrowth %>%
#   ntbt_aggregate(len ~ ., mean) %>%
#   ntbt_xtabs(len ~ .)
#   
# esoph %>%
#   ntbt_aggregate(cbind(ncases, ncontrols) ~ alcgp + tobgp, sum)
# 
# ## alias
# ## Original function to interface
# alias(yield ~ block + N*P*K, npk)
# 
# ## The interface reverses the order of data and formula
# ntbt_alias(npk, yield ~ block + N*P*K)
# 
# ## so it can be used easily in a pipeline.
# npk %>%
#   ntbt_alias(yield ~ block + N*P*K)
# 
# ## ansari.test
# ## Original function to interface
# ansari.test(extra ~ group, data = sleep)
# 
# ## The interface reverses the order of data and formula
# ntbt_ansari.test(data = sleep, extra ~ group)
# 
# ## so it can be used easily in a pipeline.
# library(magrittr)
# sleep %>%
#   ntbt_ansari.test(extra ~ group)
# 
# ## aov
# ## Original function to interface
# aov(yield ~ block + N * P + K, npk)
# 
# ## The interface reverses the order of data and formula
# ntbt_aov(npk, yield ~ block + N * P + K)
# 
# ## so it can be used easily in a pipeline.
# npk %>%
#   ntbt_aov(yield ~ block + N * P + K)
# 
# ## bartlett.test
# ## Original function to interface
# bartlett.test(count ~ spray, data = InsectSprays)
# 
# ## The interface reverses the order of data and formula
# ntbt_bartlett.test(data = InsectSprays, count ~ spray)
# 
# ## so it can be used easily in a pipeline.
# InsectSprays %>%
#   ntbt_bartlett.test(count ~ spray)
# 
# ## cor.test
# ## Original function to interface
# cor.test(~ CONT + INTG, data = USJudgeRatings)
# 
# ## The interface reverses the order of data and formula
# ntbt_cor.test(data = USJudgeRatings, ~ CONT + INTG)
# 
# ## so it can be used easily in a pipeline.
# USJudgeRatings %>%
#   ntbt_cor.test(~ CONT + INTG)
# 
# ## fligner.test
# ## Original function to interface
# fligner.test(count ~ spray, data = InsectSprays)
# 
# ## The interface reverses the order of data and formula
# ntbt_fligner.test(data = InsectSprays, count ~ spray)
# 
# ## so it can be used easily in a pipeline.
# InsectSprays %>%
#   ntbt_fligner.test(count ~ spray)
# 
# ## friedman.test
# wb <- aggregate(warpbreaks$breaks,
#                 by = list(w = warpbreaks$wool,
#                           t = warpbreaks$tension),
#                 FUN = mean)
# 
# ## Original function to interface
# friedman.test(x ~ w | t, data = wb)
# 
# ## The interface reverses the order of data and formula
# ntbt_friedman.test(data = wb, x ~ w | t)
# 
# ## so it can be used easily in a pipeline.
# wb %>%
#   ntbt_friedman.test(x ~ w | t)
# 
# ## ftable
# ## Original function to interface
# x <- ftable(Survived ~ ., data = Titanic)
# ftable(Sex ~ Class + Age, data = x)
# 
# ## The interface reverses the order of data and formula
# x <- ntbt_ftable(data = Titanic, Survived ~ .)
# ftable(data = x, Sex ~ Class + Age)
# 
# ## so it can be used easily in a pipeline.
# Titanic %>%
#   ntbt_ftable(Survived ~ .)
# 
# Titanic %>%
#   ntbt_ftable(Survived ~ .) %>%
#   ntbt_ftable(Sex ~ Class + Age)
# 
# ## getInitial
# PurTrt <- Puromycin[ Puromycin$state == "treated", ]
# 
# ## Original function to interface
# getInitial(rate ~ SSmicmen( conc, Vm, K ), PurTrt)
# 
# ## The interface reverses the order of data and formula
# ntbt_getInitial(PurTrt, rate ~ SSmicmen( conc, Vm, K ))
# 
# ## so it can be used easily in a pipeline.
# PurTrt %>%
#   ntbt_getInitial(rate ~ SSmicmen( conc, Vm, K ))
# 
# ## glm
# utils::data(anorexia, package = "MASS")
# 
# ## Original function to interface
# anorex.1 <- glm(Postwt ~ Prewt + Treat + offset(Prewt),
#                 data = anorexia)
# summary(anorex.1)
# 
# ## The interface reverses the order of data and formula
# anorex.1 <- ntbt_glm(data = anorexia,
#                      formula = Postwt ~ Prewt + Treat + offset(Prewt))
# summary(anorex.1)
# 
# ## so it can be used easily in a pipeline.
# anorexia %>%
#   ntbt_glm(Postwt ~ Prewt + Treat + offset(Prewt)) %>%
#   summary()
# 
# # A Gamma example, from McCullagh & Nelder (1989, pp. 300-2)
# data.frame(u = c(5,10,15,20,30,40,60,80,100),
#            lot1 = c(118,58,42,35,27,25,21,19,18)
#            ) %>%
#   ntbt_glm(lot1 ~ log(u), family = Gamma) %>%
#   summary()
# 
# ## kruskal.test
# ## Original function to interface
# kruskal.test(Ozone ~ Month, airquality)
# 
# ## The interface reverses the order of data and formula
# ntbt_kruskal.test(airquality, Ozone ~ Month)
# 
# ## so it can be used easily in a pipeline.
# airquality %>%
#   ntbt_kruskal.test(Ozone ~ Month)
# 
# ## lm
# ## Original function to interface
# lm(sr ~ ., LifeCycleSavings)
# 
# ## The interface reverses the order of data and formula
# ntbt_lm(LifeCycleSavings, sr ~ .)
# 
# ## so it can be used easily in a pipeline.
# library(magrittr)
# LifeCycleSavings %>%
#   ntbt_lm(sr ~ .)
# 
# LifeCycleSavings %>%
#   ntbt_lm(sr ~ .) %>%
#   summary()
# 
# ## loess
# ## Original function to interface
# loess(dist ~ speed, cars)
# 
# ## The interface reverses the order of data and formula
# ntbt_loess(cars, dist ~ speed)
# 
# ## so it can be used easily in a pipeline.
# cars %>%
#   ntbt_loess(dist ~ speed)
#   
# cars %>%
#   ntbt_loess(dist ~ speed,
#              control = loess.control(surface = "direct"))
# 
# ## lqs
# library(MASS)
# 
# ## Original function to interface
# set.seed(123) # make reproducible
# lqs(stack.loss ~ ., data = stackloss)
# 
# ## The interface reverses the order of data and formula
# set.seed(123) # make reproducible
# ntbt_lqs(data = stackloss, stack.loss ~ .)
# 
# ## so it can be used easily in a pipeline.
# set.seed(123) # make reproducible
# stackloss %>%
#   ntbt_lqs(stack.loss ~ .)
# 
# ## model.frame
# ## Original function to interface
# model.frame(dist ~ speed, data = cars)
# 
# ## The interface reverses the order of data and formula
# ntbt_model.frame(data = cars, dist ~ speed)
# 
# ## so it can be used easily in a pipeline.
# cars %>%
#   ntbt_model.frame(dist ~ speed)
# 
# ## model.matrix
# dd <- data.frame(a = gl(3, 4),
#                  b = gl(4, 1, 12)) # balanced 2-way
# 
# ## Original function to interface
# model.matrix(~ a + b, dd)
# 
# ## The interface reverses the order of data and formula
# ntbt_model.matrix(dd, ~ a + b)
# 
# ## so it can be used easily in a pipeline.
# dd %>%
#   ntbt_model.matrix(~ a + b)
# 
# ## mood.test
# ## Original function to interface
# mood.test(extra ~ group, data = sleep)
# 
# ## The interface reverses the order of data and formula
# ntbt_mood.test(data = sleep, extra ~ group)
# 
# ## so it can be used easily in a pipeline.
# sleep %>%
#   ntbt_mood.test(extra ~ group)
# 
# ## nls
# ## Original function to interface
# nls(density ~ SSlogis(log(conc), Asym, xmid, scal), DNase)
# 
# ## The interface reverses the order of data and formula
# ntbt_nls(data = DNase, density ~ SSlogis(log(conc), Asym, xmid, scal))
# 
# ## so it can be used easily in a pipeline.
# DNase %>%
#   ntbt_nls(density ~ SSlogis(log(conc), Asym, xmid, scal))
# 
# ## oneway.test
# ## Original function to interface
# oneway.test(extra ~ group, data = sleep)
# 
# ## The interface reverses the order of data and formula
# ntbt_oneway.test(data = sleep, extra ~ group)
# 
# ## so it can be used easily in a pipeline.
# sleep %>%
#   ntbt_oneway.test(extra ~ group)
# 
# ## ppr
# ## Original function to interface
# ppr(log(perm) ~ area + peri + shape, data = rock,
#     nterms = 2, max.terms = 5)
# 
# ## The interface reverses the order of data and formula
# ntbt_ppr(data = rock, log(perm) ~ area + peri + shape,
#          nterms = 2, max.terms = 5)
# 
# ## so it can be used easily in a pipeline.
# rock %>%
#   ntbt_ppr(log(perm) ~ area + peri + shape,
#            nterms = 2, max.terms = 5)
# 
# ## prcomp
# ## Original function to interface
# prcomp(~ Murder + Assault + Rape, data = USArrests, scale = TRUE)
# 
# ## The interface reverses the order of data and formula
# ntbt_prcomp(data = USArrests, ~ Murder + Assault + Rape, scale = TRUE)
# 
# ## so it can be used easily in a pipeline.
# USArrests %>%
#   ntbt_prcomp(~ Murder + Assault + Rape, scale = TRUE)
# 
# ## princomp
# ## Original function to interface
# princomp(~ ., data = USArrests, cor = TRUE)
# 
# ## The interface reverses the order of data and formula
# ntbt_princomp(data = USArrests, ~ ., cor = TRUE)
# 
# ## so it can be used easily in a pipeline.
# USArrests %>%
#   ntbt_princomp(~ ., cor = TRUE)
# 
# ## quade.test
# wb <- aggregate(warpbreaks$breaks,
#                 by = list(w = warpbreaks$wool,
#                           t = warpbreaks$tension),
#                 FUN = mean)
# 
# ## Original function to interface
# quade.test(x ~ w | t, data = wb)
# 
# ## The interface reverses the order of data and formula
# ntbt_quade.test(data = wb, x ~ w | t)
# 
# ## so it can be used easily in a pipeline.
# wb %>%
#   ntbt_quade.test(x ~ w | t)
# 
# ## replications
# ## From Venables and Ripley (2002) p.165.
# N <- c(0,1,0,1,1,1,0,0,0,1,1,0,1,1,0,0,1,0,1,0,1,1,0,0)
# P <- c(1,1,0,0,0,1,0,1,1,1,0,0,0,1,0,1,1,0,0,1,0,1,1,0)
# K <- c(1,0,0,1,0,1,1,0,0,1,0,1,0,1,1,0,0,0,1,1,1,0,1,0)
# yield <- c(49.5,62.8,46.8,57.0,59.8,58.5,55.5,56.0,62.8,55.8,69.5,
#            55.0, 62.0,48.8,45.5,44.2,52.0,51.5,49.8,48.8,57.2,59.0,53.2,56.0)
# 
# npk <- data.frame(block = gl(6,4), N = factor(N), P = factor(P),
#                   K = factor(K), yield = yield)
# 
# ## Original function to interface
# replications(~ . - yield, npk)
# 
# ## The interface reverses the order of data and formula
# ntbt_replications(npk, ~ . - yield)
# 
# ## so it can be used easily in a pipeline.
# npk %>%
#   ntbt_replications(~ . - yield)
# 
# ## t.test
# ## Original function to interface
# t.test(extra ~ group, data = sleep)
# 
# ## The interface reverses the order of data and formula
# ntbt_t.test(data = sleep, extra ~ group)
# 
# ## so it can be used easily in a pipeline.
# sleep %>%
#   ntbt_t.test(extra ~ group)
# 
# ## var.test
# ## Original function to interface
# var.test(extra ~ group, data = sleep)
# 
# ## The interface reverses the order of data and formula
# ntbt_var.test(data = sleep, extra ~ group)
# 
# ## so it can be used easily in a pipeline.
# sleep %>%
#   ntbt_var.test(extra ~ group)
# 
# ## wilcox.test
# ## Original function to interface
# wilcox.test(extra ~ group, data = sleep)
# 
# ## The interface reverses the order of data and formula
# ntbt_wilcox.test(data = sleep, extra ~ group)
# 
# ## so it can be used easily in a pipeline.
# sleep %>%
#   ntbt_wilcox.test(extra ~ group)
# 
# ## xtabs
# ## Original function to interface
# ag <- aggregate(len ~ ., data = ToothGrowth, mean)
# xtabs(len ~ ., data = ag)
# 
# ## The interface reverses the order of data and formula
# ag <- ntbt_aggregate(ToothGrowth, len ~ ., mean)
# ntbt_xtabs(ag, len ~ .)
# 
# ## so it can be used easily in a pipeline.
# ToothGrowth %>%
#   ntbt_aggregate(len ~ ., mean) %>%
#   ntbt_xtabs(len ~ .)
# ## End(Not run)