id
stringlengths 40
40
| repo_name
stringlengths 5
110
| path
stringlengths 2
233
| content
stringlengths 0
1.03M
⌀ | size
int32 0
60M
⌀ | license
stringclasses 15
values |
|---|---|---|---|---|---|
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | allr/r-instrumented | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | Mouseomics/R | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | SurajGupta/r-source | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
1d4e14034ce59af2e0a940c58fd99dbb4ea970c8 | hfang-bristol/dcGOR | man/onto.UP.Rd | \name{onto.UP}
\alias{onto.UP}
\title{UniProtKB UniPathway (UP).}
\usage{
onto.UP <- dcRDataLoader(RData='onto.UP')
}
\description{
An R object that contains information on UniProtKB UniPathway terms. These terms are organised as a direct acyclic graph (DAG), which is further stored as an object of the class 'igraph' (see \url{http://igraph.org/r/doc/aaa-igraph-package.html}). UniProtKB UniPathway (UP) is a fully manually curated resource for the representation and annotation of metabolic pathways, being used as a controlled vocabulary for pathway annotation in UniProtKB.
}
\value{
an object of S4 class \link{Onto}. It has slots for "nodeInfo" and "adjMatrix"
\itemize{
\item{\code{nodeInfo}: an object of S4 class \link{InfoDataFrame}, describing information on nodes/terms including: "term_id" (i.e. Term ID), "term_name" (i.e. Term Name), "term_namespace" (i.e. Term Namespace), and "term_distance" (i.e. Term Distance: the distance to the root; always 0 for the root itself)}
\item{\code{adjMatrix}: an object of S4 class \link{AdjData}, containing adjacency data matrix, with rows for parent (arrow-outbound) and columns for children (arrow-inbound)}
}
}
\references{
Morgat et al. (2006) UniPathway: a resource for the exploration and annotation of metabolic pathways. \emph{Nucleic Acids Res}, 40:D761-9.
\cr
Fang H and Gough J. (2013) dcGO: database of domain-centric ontologies on functions, phenotypes, diseases and more. \emph{Nucleic Acids Res}, 41(Database issue):D536-44.
}
\keyword{datasets}
\examples{
onto.UP <- dcRDataLoader(RData='onto.UP')
onto.UP
}
| 1,613 | gpl-2.0 |
28ec54d3b146aea8ed98aebf6ce1c95ce863bfe1 | Alanocallaghan/GenVisR | man/waterfall_qual.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/waterfall_qual.R
\name{waterfall_qual}
\alias{waterfall_qual}
\title{Check input to mutSpec}
\usage{
waterfall_qual(x, y, z, file_type, label_col)
}
\arguments{
\item{x}{a data frame in annotation format}
\item{y}{a data frame containing clinical data or a null object}
\item{z}{a data frame containing mutation burden information or a null object}
\item{file_type}{Character string specifying the input format to expect in x}
\item{label_col}{Character string specifying the column name of a label
column}
}
\value{
a list of data frames passing quality checks
}
\description{
Perform a data quality check on input to mutSpec
}
| 712 | cc0-1.0 |
305193e085679cd013685e55ac8f123d26147158 | waddella/loon | R/man/l_configure.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/l_configure.R
\name{l_configure}
\alias{l_configure}
\alias{[<-.loon}
\title{Modify one or multiple plot states}
\usage{
l_configure(target, ...)
}
\arguments{
\item{target}{either an object of class loon or a vector that specifies the
widget, layer, glyph, navigator or context completely. The widget is
specified by the widget path name (e.g. \code{'.l0.plot'}), the remaining
objects by their ids.}
\item{...}{state=value pairs}
}
\description{
All of loon's displays have plot states. Plot states specify
what is displayed, how it is displayed and if and how the plot is linked
with other loon plots. Layers, glyphs, navigators and contexts have states
too (also refered to as plot states). This function modifies one or
multiple plot states.
}
\examples{
p <- l_plot(iris, color = iris$Species)
l_configure(p, color='red')
p['size'] <- ifelse(iris$Species == "versicolor", 2, 8)
}
\seealso{
\code{\link{l_cget}}, \code{\link{l_info_states}},
\code{\link{l_create_handle}}
}
| 1,072 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | kmillar/rho | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
d2b1232d8d96a1f087089abbcbe78e9834e95204 | Burningcode/rmongodb | rmongodb/man/mongo.find.Rd | % File rmongodb/man/mongo.find.Rd
\name{mongo.find}
\alias{mongo.find}
\title{Find records in a collection}
\description{
Find records in a collection that match a given query.
See \url{http://www.mongodb.org/display/DOCS/Querying}.
}
\usage{
mongo.find(mongo, ns, query=mongo.bson.empty(),
sort=mongo.bson.empty(), fields=mongo.bson.empty(),
limit=0L, skip=0L, options=0L)
}
\arguments{
\item{mongo}{(\link{mongo}) a mongo connection object.}
\item{ns}{(string) namespace of the collection from which to find records.}
\item{query}{(\link{mongo.bson}) The criteria with which to match the records to be found.
The default of mongo.bson.empty() will cause the the very first record in the collection to be returned.
Alternately, \code{query} may be a list which will be converted to a mongo.bson object
by \code{\link{mongo.bson.from.list}()}.}
\item{sort}{(\link{mongo.bson}) The desired fields by which to sort the returned records. The default of mongo.bson.empty()
indicates that no special sorting is to be done; the records will come back in the order that indexes locate them.
Alternately, \code{sort} may be a list which will be converted to a mongo.bson object
by \code{\link{mongo.bson.from.list}()}.}
\item{fields}{(\link{mongo.bson}) The desired fields which are to be returned from the matching record.
The default of mongo.bson.empty() will cause all fields of the matching record to be returned;
however, specific fields may be specified to cut down on network traffic and memory overhead.
Alternately, \code{fields} may be a list which will be converted to a mongo.bson object
by \code{\link{mongo.bson.from.list}()}.}
\item{limit}{(as.integer) The maximum number of records to be returned. A limit of 0L will return all matching records not skipped.}
\item{skip}{(as.integer) The number of matching records to skip before returning subsequent matching records.}
\item{options}{(integer vector) Flags governing the requested operation as follows:
\itemize{
\item{\link{mongo.find.cursor.tailable}}
\item{\link{mongo.find.slave.ok}}
\item{\link{mongo.find.oplog.replay}}
\item{\link{mongo.find.no.cursor.timeout}}
\item{\link{mongo.find.await.data}}
\item{\link{mongo.find.exhaust}}
\item{\link{mongo.find.partial.results}}
}}
}
\value{
(\link{mongo.cursor}) An object of class "mongo.cursor" which is used to step through the matching records.
Note that an empty cursor will be returned if a database error occurred.\cr
\code{\link{mongo.get.server.err}()} and \code{\link{mongo.get.server.err.string}()} may be examined in that case.
}
\examples{
mongo <- mongo.create()
if (mongo.is.connected(mongo)) {
buf <- mongo.bson.buffer.create()
mongo.bson.buffer.append(buf, "age", 18L)
query <- mongo.bson.from.buffer(buf)
# Find the first 100 records
# in collection people of database test where age == 18
cursor <- mongo.find(mongo, "test.people", query, limit=100L)
# Step though the matching records and display them
while (mongo.cursor.next(cursor))
print(mongo.cursor.value(cursor))
mongo.cursor.destroy(cursor)
# shorthand: find all records where age=32, sorted by name,
# and only return the name & address fields:
cursor <- mongo.find(mongo, "test.people", list(age=32),
list(name=1L), list(name=1L, address=1L))
}
}
\seealso{
\code{\link{mongo.cursor}},\cr
\code{\link{mongo.cursor.next}},\cr
\code{\link{mongo.cursor.value}},\cr
\code{\link{mongo.find.one}},\cr
\code{\link{mongo.insert}},\cr
\code{\link{mongo.index.create}},\cr
\code{\link{mongo.update}},\cr
\code{\link{mongo.remove}},\cr
\link{mongo},\cr
\link{mongo.bson}.
}
| 3,762 | apache-2.0 |
321c872a44f002d392e0f468e9e3ba6a9a8942f7 | RubyFore/CensusAPITools | man/bindCensusDataToMap.Rd | % Generated by roxygen2 (4.1.0): do not edit by hand
% Please edit documentation in R/bindCensusDataToMap.R
\name{bindCensusDataToMap}
\alias{bindCensusDataToMap}
\title{Binds Census data to S4 dataframe}
\usage{
bindCensusDataToMap(df, spdf)
}
\arguments{
\item{df}{a census dataframe}
\item{spdf}{an S4 dataframe}
}
\value{
A spatial polygons dataframe with extra columns in @data
}
\description{
Binds Census data to a Spatial Polygons Dataframe from tigris package using GEOID as unique identifier.
}
| 507 | gpl-2.0 |
db47035bbf33a6806868390de87e8ff57e21b0c7 | pegasus-isi/pegasus | packages/pegasus-dax-r/Pegasus/Workflow/man/AddDependency.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/workflow.R
\name{AddDependency}
\alias{AddDependency}
\title{Add a dependency to the workflow}
\usage{
AddDependency(workflow, dep)
}
\arguments{
\item{workflow}{The Workflow object}
\item{dep}{The dependency object}
}
\value{
The Workflow object containing the dependency
}
\description{
Add a dependency to the workflow
}
\seealso{
\code{\link{Workflow}}, \code{\link{Dependency}},
\code{\link{Depends}}, \code{\link{RemoveDependency}}
}
| 520 | apache-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | allr/timeR | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | MouseGenomics/R | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | jimhester/r-source | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | ArunChauhan/cxxr | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | krlmlr/cxxr | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
28ec54d3b146aea8ed98aebf6ce1c95ce863bfe1 | ahwagner/GenVisR | man/waterfall_qual.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/waterfall_qual.R
\name{waterfall_qual}
\alias{waterfall_qual}
\title{Check input to mutSpec}
\usage{
waterfall_qual(x, y, z, file_type, label_col)
}
\arguments{
\item{x}{a data frame in annotation format}
\item{y}{a data frame containing clinical data or a null object}
\item{z}{a data frame containing mutation burden information or a null object}
\item{file_type}{Character string specifying the input format to expect in x}
\item{label_col}{Character string specifying the column name of a label
column}
}
\value{
a list of data frames passing quality checks
}
\description{
Perform a data quality check on input to mutSpec
}
| 712 | cc0-1.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | minux/R | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
d2b1232d8d96a1f087089abbcbe78e9834e95204 | gerald-lindsly/rmongodb | rmongodb/man/mongo.find.Rd | % File rmongodb/man/mongo.find.Rd
\name{mongo.find}
\alias{mongo.find}
\title{Find records in a collection}
\description{
Find records in a collection that match a given query.
See \url{http://www.mongodb.org/display/DOCS/Querying}.
}
\usage{
mongo.find(mongo, ns, query=mongo.bson.empty(),
sort=mongo.bson.empty(), fields=mongo.bson.empty(),
limit=0L, skip=0L, options=0L)
}
\arguments{
\item{mongo}{(\link{mongo}) a mongo connection object.}
\item{ns}{(string) namespace of the collection from which to find records.}
\item{query}{(\link{mongo.bson}) The criteria with which to match the records to be found.
The default of mongo.bson.empty() will cause the the very first record in the collection to be returned.
Alternately, \code{query} may be a list which will be converted to a mongo.bson object
by \code{\link{mongo.bson.from.list}()}.}
\item{sort}{(\link{mongo.bson}) The desired fields by which to sort the returned records. The default of mongo.bson.empty()
indicates that no special sorting is to be done; the records will come back in the order that indexes locate them.
Alternately, \code{sort} may be a list which will be converted to a mongo.bson object
by \code{\link{mongo.bson.from.list}()}.}
\item{fields}{(\link{mongo.bson}) The desired fields which are to be returned from the matching record.
The default of mongo.bson.empty() will cause all fields of the matching record to be returned;
however, specific fields may be specified to cut down on network traffic and memory overhead.
Alternately, \code{fields} may be a list which will be converted to a mongo.bson object
by \code{\link{mongo.bson.from.list}()}.}
\item{limit}{(as.integer) The maximum number of records to be returned. A limit of 0L will return all matching records not skipped.}
\item{skip}{(as.integer) The number of matching records to skip before returning subsequent matching records.}
\item{options}{(integer vector) Flags governing the requested operation as follows:
\itemize{
\item{\link{mongo.find.cursor.tailable}}
\item{\link{mongo.find.slave.ok}}
\item{\link{mongo.find.oplog.replay}}
\item{\link{mongo.find.no.cursor.timeout}}
\item{\link{mongo.find.await.data}}
\item{\link{mongo.find.exhaust}}
\item{\link{mongo.find.partial.results}}
}}
}
\value{
(\link{mongo.cursor}) An object of class "mongo.cursor" which is used to step through the matching records.
Note that an empty cursor will be returned if a database error occurred.\cr
\code{\link{mongo.get.server.err}()} and \code{\link{mongo.get.server.err.string}()} may be examined in that case.
}
\examples{
mongo <- mongo.create()
if (mongo.is.connected(mongo)) {
buf <- mongo.bson.buffer.create()
mongo.bson.buffer.append(buf, "age", 18L)
query <- mongo.bson.from.buffer(buf)
# Find the first 100 records
# in collection people of database test where age == 18
cursor <- mongo.find(mongo, "test.people", query, limit=100L)
# Step though the matching records and display them
while (mongo.cursor.next(cursor))
print(mongo.cursor.value(cursor))
mongo.cursor.destroy(cursor)
# shorthand: find all records where age=32, sorted by name,
# and only return the name & address fields:
cursor <- mongo.find(mongo, "test.people", list(age=32),
list(name=1L), list(name=1L, address=1L))
}
}
\seealso{
\code{\link{mongo.cursor}},\cr
\code{\link{mongo.cursor.next}},\cr
\code{\link{mongo.cursor.value}},\cr
\code{\link{mongo.find.one}},\cr
\code{\link{mongo.insert}},\cr
\code{\link{mongo.index.create}},\cr
\code{\link{mongo.update}},\cr
\code{\link{mongo.remove}},\cr
\link{mongo},\cr
\link{mongo.bson}.
}
| 3,762 | apache-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | kmillar/cxxr | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | rho-devel/rho | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | cxxr-devel/cxxr | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | reactorlabs/gnur | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | krlmlr/r-source | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
5c7a722c94c89cbdf1a654b846c02ca04fed9f1c | SensePlatform/R | src/library/stats/man/Hypergeometric.Rd | % File src/library/stats/man/Hypergeometric.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{Hypergeometric}
\alias{Hypergeometric}
\alias{dhyper}
\alias{phyper}
\alias{qhyper}
\alias{rhyper}
\title{The Hypergeometric Distribution}
\description{
Density, distribution function, quantile function and random
generation for the hypergeometric distribution.
}
\usage{
dhyper(x, m, n, k, log = FALSE)
phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)
qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)
rhyper(nn, m, n, k)
}
\arguments{
\item{x, q}{vector of quantiles representing the number of white balls
drawn without replacement from an urn which contains both black and
white balls.}
\item{m}{the number of white balls in the urn.}
\item{n}{the number of black balls in the urn.}
\item{k}{the number of balls drawn from the urn.}
\item{p}{probability, it must be between 0 and 1.}
\item{nn}{number of observations. If \code{length(nn) > 1}, the length
is taken to be the number required.}
\item{log, log.p}{logical; if TRUE, probabilities p are given as log(p).}
\item{lower.tail}{logical; if TRUE (default), probabilities are
\eqn{P[X \le x]}, otherwise, \eqn{P[X > x]}.}
}
\value{
\code{dhyper} gives the density,
\code{phyper} gives the distribution function,
\code{qhyper} gives the quantile function, and
\code{rhyper} generates random deviates.
Invalid arguments will result in return value \code{NaN}, with a warning.
The length of the result is determined by \code{n} for
\code{rhyper}, and is the maximum of the lengths of the
numerical arguments for the other functions.
The numerical arguments other than \code{n} are recycled to the
length of the result. Only the first elements of the logical
arguments are used.
}
\details{
The hypergeometric distribution is used for sampling \emph{without}
replacement. The density of this distribution with parameters
\code{m}, \code{n} and \code{k} (named \eqn{Np}, \eqn{N-Np}, and
\eqn{n}, respectively in the reference below) is given by
\deqn{
p(x) = \left. {m \choose x}{n \choose k-x} \right/ {m+n \choose k}%
}{p(x) = choose(m, x) choose(n, k-x) / choose(m+n, k)}
for \eqn{x = 0, \ldots, k}.
Note that \eqn{p(x)} is non-zero only for
\eqn{\max(0, k-n) \le x \le \min(k, m)}{max(0, k-n) <= x <= min(k, m)}.
With \eqn{p := m/(m+n)} (hence \eqn{Np = N \times p} in the
reference's notation), the first two moments are mean
\deqn{E[X] = \mu = k p} and variance
\deqn{\mbox{Var}(X) = k p (1 - p) \frac{m+n-k}{m+n-1},}{%
Var(X) = k p (1 - p) * (m+n-k)/(m+n-1),}
which shows the closeness to the Binomial\eqn{(k,p)} (where the
hypergeometric has smaller variance unless \eqn{k = 1}).
The quantile is defined as the smallest value \eqn{x} such that
\eqn{F(x) \ge p}, where \eqn{F} is the distribution function.
If one of \eqn{m, n, k}, exceeds \code{\link{.Machine}$integer.max},
currently the equivalent of \code{qhyper(runif(nn), m,n,k)} is used,
when a binomial approximation may be considerably more efficient.
}
\source{
\code{dhyper} computes via binomial probabilities, using code
contributed by Catherine Loader (see \code{\link{dbinom}}).
\code{phyper} is based on calculating \code{dhyper} and
\code{phyper(...)/dhyper(...)} (as a summation), based on ideas of Ian
Smith and Morten Welinder.
\code{qhyper} is based on inversion.
\code{rhyper} is based on a corrected version of
Kachitvichyanukul, V. and Schmeiser, B. (1985).
Computer generation of hypergeometric random variates.
\emph{Journal of Statistical Computation and Simulation},
\bold{22}, 127--145.
}
\references{
Johnson, N. L., Kotz, S., and Kemp, A. W. (1992)
\emph{Univariate Discrete Distributions},
Second Edition. New York: Wiley.
}
\seealso{
\link{Distributions} for other standard distributions.
}
\examples{
m <- 10; n <- 7; k <- 8
x <- 0:(k+1)
rbind(phyper(x, m, n, k), dhyper(x, m, n, k))
all(phyper(x, m, n, k) == cumsum(dhyper(x, m, n, k))) # FALSE
\donttest{## but error is very small:
signif(phyper(x, m, n, k) - cumsum(dhyper(x, m, n, k)), digits = 3)
}}
\keyword{distribution}
| 4,269 | gpl-2.0 |
ef15b277c74e51552b90e0b4d04aa4b0a7cdf134 | jchiquet/PLNmodels | man/getModel.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/PLNPCAfamily-S3methods.R,
% R/PLNfamily-S3methods.R, R/PLNmixturefamily-S3methods.R,
% R/PLNnetworkfamily-S3methods.R
\name{getModel.PLNPCAfamily}
\alias{getModel.PLNPCAfamily}
\alias{getModel}
\alias{getModel.PLNmixturefamily}
\alias{getModel.PLNnetworkfamily}
\title{Model extraction from a collection of models}
\usage{
\method{getModel}{PLNPCAfamily}(Robject, var, index = NULL)
getModel(Robject, var, index)
\method{getModel}{PLNmixturefamily}(Robject, var, index = NULL)
\method{getModel}{PLNnetworkfamily}(Robject, var, index = NULL)
}
\arguments{
\item{Robject}{an R6 object with class \code{\link{PLNPCAfamily}} or \code{\link{PLNnetworkfamily}}}
\item{var}{value of the parameter (\code{rank} for PLNPCA, \code{sparsity} for PLNnetwork) that identifies the model to be extracted from the collection. If no exact match is found, the model with closest parameter value is returned with a warning.}
\item{index}{Integer index of the model to be returned. Only the first value is taken into account.}
}
\value{
Sends back an object with class \code{\link{PLNPCAfit}} or \code{\link{PLNnetworkfit}}.
}
\description{
Model extraction from a collection of models
}
\section{Methods (by class)}{
\itemize{
\item \code{PLNPCAfamily}: Model extraction for \code{\link{PLNPCAfamily}}
\item \code{PLNmixturefamily}: Model extraction for \code{\link{PLNmixturefamily}}
\item \code{PLNnetworkfamily}: Model extraction for \code{\link{PLNnetworkfamily}}
}}
\examples{
\dontrun{
data(trichoptera)
trichoptera <- prepare_data(trichoptera$Abundance, trichoptera$Covariate)
myPCA <- PLNPCA(Abundance ~ 1 + offset(log(Offset)), data = trichoptera, ranks = 1:5)
myModel <- getModel(myPCA, 2)
}
}
| 1,775 | gpl-3.0 |
eb8d94146ecd562fc178432005f389887200abef | prakash5801/optR | optr/man/LU.decompose.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/LU.R
\name{LU.decompose}
\alias{LU.decompose}
\title{LU decomposition}
\usage{
LU.decompose(A, tol = 1e-07)
}
\arguments{
\item{A}{: Input Matrix}
\item{tol}{: tolerance}
}
\value{
A : Transformed matrix with Upper part of the triangele is (U) and Lower part of the triangular is L (Diagnoal for the L matrix is 1)
}
\description{
The function decomposes matrix A into LU with L lower matrix and U as upper matrix
}
\examples{
A<-matrix(c(0,-1,1, -1,2,-1,2,-1,0), nrow=3,ncol=3, byrow = TRUE)
Z<-optR(A, tol=1e-7, method="LU")
}
| 610 | mit |
4adabed7f6de624c93dcbb7e315ed1fb560fce44 | mmollina/polymap | man/elim_redundant.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/eliminate_redundant.R
\name{elim_redundant}
\alias{elim_redundant}
\title{Eliminate redundant markers}
\usage{
elim_redundant(input.seq)
}
\arguments{
\item{input.seq}{an object of class \code{'polymap.sequence'}}
\item{x}{an object \code{'polymap.unique.seq'}}
\item{...}{currently ignored}
}
\value{
An object of class \code{'polymap.unique.seq'} which
is a list containing the following components:
\item{unique.seq}{an object of class \code{'polymap.sequence'}
with the redundant markers removed}
\item{kept}{a vector containing the name of the kept markers}
\item{eliminated}{a vector containing the name of the eliminated markers}
}
\description{
Eliminate markers with identical infomation leaving only one
representative marker. At the end of the analysis, the markers
are placed in the final map.
}
\examples{
\dontrun{
data(hexafake)
all.mrk<-make_seq_polymap(hexafake, 'all')
red.mrk<-elim_redundant(all.mrk)
plot(red.mrk)
unique.mrks<-make_seq_polymap(red.mrk)
}
}
\references{
Mollinari, M., and Garcia, A. A. F. (2017) Linkage
analysis and haplotype phasing in experimental autopolyploid
populations with high ploidy level using hidden Markov
models, _submited_
}
\author{
Marcelo Mollinari, \email{[email protected]}
}
| 1,378 | gpl-3.0 |
8525389a1d075dce3e87b05ad77e03676da3ee32 | UMMS-Biocore/debrowser | man/getPlotArea.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/heatmap.R
\name{getPlotArea}
\alias{getPlotArea}
\title{getPlotArea}
\usage{
getPlotArea(input = NULL, session = NULL)
}
\arguments{
\item{input, }{input variables}
\item{session, }{session}
}
\value{
heatmapply/heatmap.2 plot area
}
\description{
returns plot area either for heatmaply or heatmap.2
}
\examples{
x <- getPlotArea()
}
| 418 | gpl-3.0 |
5d424ac0dfb30c49b248174afa43ad51adf0dec8 | klapaukh/hangler | man/solveDeli.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/spline.R
\name{solveDeli}
\alias{solveDeli}
\title{Find the delta i values along the spiline}
\usage{
solveDeli(dx, dy, thetai, thetaj)
}
\description{
Find the delta i values along the spiline
}
| 274 | gpl-3.0 |
e6a44a46d0380f5057f00b243859b7e50edcb28c | tlverse/sl3 | man/Lrnr_expSmooth.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/Lrnr_expSmooth.R
\docType{class}
\name{Lrnr_expSmooth}
\alias{Lrnr_expSmooth}
\title{Exponential Smoothing state space model}
\format{
\code{\link{R6Class}} object.
}
\value{
Learner object with methods for training and prediction. See
\code{\link{Lrnr_base}} for documentation on learners.
}
\description{
This learner supports exponential smoothing models using
\code{\link[forecast]{ets}}.
}
\section{Parameters}{
\itemize{
\item \code{model="ZZZ"}: Three-character string identifying method. In all
cases, "N"=none, "A"=additive, "M"=multiplicative, and "Z"=automatically
selected. The first letter denotes the error type, second letter denotes
the trend type, third letter denotes the season type. For example, "ANN"
is simple exponential smoothing with additive errors, "MAM" is
multiplicative Holt-Winters' methods with multiplicative errors, etc.
\item \code{damped=NULL}: If TRUE, use a damped trend (either additive or
multiplicative). If NULL, both damped and non-damped trends will be tried
and the best model (according to the information criterion ic) returned.
\item \code{alpha=NULL}: Value of alpha. If NULL, it is estimated.
\item \code{beta=NULL}: Value of beta. If NULL, it is estimated.
\item \code{gamma=NULL}: Value of gamma. If NULL, it is estimated.
\item \code{phi=NULL}: Value of phi. If NULL, it is estimated.
\item \code{lambda=NULL}: Box-Cox transformation parameter. Ignored if
\code{NULL}. When lambda is specified, \code{additive.only} is set to
\code{TRUE}.
\item \code{additive.only=FALSE}: If \code{TRUE}, will only consider
additive models.
\item \code{biasadj=FALSE}: Use adjusted back-transformed mean for Box-Cox
transformations.
\item \code{lower=c(rep(1e-04, 3), 0.8)}: Lower bounds for the parameters
(alpha, beta, gamma, phi).
\item \code{upper=c(rep(0.9999,3), 0.98)}: Upper bounds for the parameters
(alpha, beta, gamma, phi)
\item \code{opt.crit="lik"}: Optimization criterion.
\item \code{nmse=3}: Number of steps for average multistep MSE (1 <= nmse
<= 30).
\item \code{bounds="both"}" Type of parameter space to impose: "usual"
indicates all parameters must lie between specified lower and upper
bounds; "admissible" indicates parameters must lie in the admissible
space; "both" (default) takes the intersection of these regions.
\item \code{ic="aic"}: Information criterion to be used in model
selection.
\item \code{restrict=TRUE}: If TRUE, models with infinite variance will not
be allowed.
\item \code{allow.multiplicative.trend=FALSE}: If TRUE, models with
multiplicative trend are allowed when searching for a model.
\item \code{use.initial.values=FALSE}: If \code{TRUE} and model is of class
"ets", then the initial values in the model are also not re-estimated.
\item \code{n.ahead}: The forecast horizon. If not specified, returns
forecast of size \code{task$X}.
\item \code{freq=1}: the number of observations per unit of time.
\item \code{...}: Other parameters passed to \code{\link[forecast]{ets}.}
}
}
\examples{
library(origami)
data(bsds)
folds <- make_folds(bsds,
fold_fun = folds_rolling_window, window_size = 500,
validation_size = 100, gap = 0, batch = 50
)
task <- sl3_Task$new(
data = bsds,
folds = folds,
covariates = c(
"weekday", "temp"
),
outcome = "cnt"
)
expSmooth_lrnr <- make_learner(Lrnr_expSmooth)
train_task <- training(task, fold = task$folds[[1]])
valid_task <- validation(task, fold = task$folds[[1]])
expSmooth_fit <- expSmooth_lrnr$train(train_task)
expSmooth_preds <- expSmooth_fit$predict(valid_task)
}
\seealso{
Other Learners:
\code{\link{Custom_chain}},
\code{\link{Lrnr_HarmonicReg}},
\code{\link{Lrnr_arima}},
\code{\link{Lrnr_bartMachine}},
\code{\link{Lrnr_base}},
\code{\link{Lrnr_bayesglm}},
\code{\link{Lrnr_bilstm}},
\code{\link{Lrnr_caret}},
\code{\link{Lrnr_cv_selector}},
\code{\link{Lrnr_cv}},
\code{\link{Lrnr_dbarts}},
\code{\link{Lrnr_define_interactions}},
\code{\link{Lrnr_density_discretize}},
\code{\link{Lrnr_density_hse}},
\code{\link{Lrnr_density_semiparametric}},
\code{\link{Lrnr_earth}},
\code{\link{Lrnr_gam}},
\code{\link{Lrnr_ga}},
\code{\link{Lrnr_gbm}},
\code{\link{Lrnr_glm_fast}},
\code{\link{Lrnr_glmnet}},
\code{\link{Lrnr_glm}},
\code{\link{Lrnr_grf}},
\code{\link{Lrnr_gru_keras}},
\code{\link{Lrnr_gts}},
\code{\link{Lrnr_h2o_grid}},
\code{\link{Lrnr_hal9001}},
\code{\link{Lrnr_haldensify}},
\code{\link{Lrnr_hts}},
\code{\link{Lrnr_independent_binomial}},
\code{\link{Lrnr_lightgbm}},
\code{\link{Lrnr_lstm_keras}},
\code{\link{Lrnr_mean}},
\code{\link{Lrnr_multiple_ts}},
\code{\link{Lrnr_multivariate}},
\code{\link{Lrnr_nnet}},
\code{\link{Lrnr_nnls}},
\code{\link{Lrnr_optim}},
\code{\link{Lrnr_pca}},
\code{\link{Lrnr_pkg_SuperLearner}},
\code{\link{Lrnr_polspline}},
\code{\link{Lrnr_pooled_hazards}},
\code{\link{Lrnr_randomForest}},
\code{\link{Lrnr_ranger}},
\code{\link{Lrnr_revere_task}},
\code{\link{Lrnr_rpart}},
\code{\link{Lrnr_rugarch}},
\code{\link{Lrnr_screener_augment}},
\code{\link{Lrnr_screener_coefs}},
\code{\link{Lrnr_screener_correlation}},
\code{\link{Lrnr_screener_importance}},
\code{\link{Lrnr_sl}},
\code{\link{Lrnr_solnp_density}},
\code{\link{Lrnr_solnp}},
\code{\link{Lrnr_stratified}},
\code{\link{Lrnr_subset_covariates}},
\code{\link{Lrnr_svm}},
\code{\link{Lrnr_tsDyn}},
\code{\link{Lrnr_ts_weights}},
\code{\link{Lrnr_xgboost}},
\code{\link{Pipeline}},
\code{\link{Stack}},
\code{\link{define_h2o_X}()},
\code{\link{undocumented_learner}}
}
\concept{Learners}
\keyword{data}
| 5,550 | gpl-3.0 |
d2c9e530567e48c931b38adbf45cc35d54010376 | briandk/per-assessment-guides | RPackage/man/PERAssessmentGuides-package.Rd | % Generated by roxygen2 (4.1.0): do not edit by hand
% Please edit documentation in R/PERAssessmentGuides-Package.R
\docType{package}
\name{PERAssessmentGuides-package}
\alias{PERAssessmentGuides-package}
\title{PER Assessment Guide Templates:}
\description{
This package contains an RMarkdown template/skeleton for generating assessment guides
\tabular{ll}{
Package: \tab granovaGG\cr
Version: \tab 0.1\cr
License: \tab GPL (>= 2)\cr
}
}
\author{
Brian A. Danielak \email{[email protected]}\cr
}
| 505 | mit |
c14511b8c4611b464552e3dac68ae8fb3b47549d | SimonSchafferer/CLIHelperPackage | man/FilesOutput.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/singleRCodeFile.R
\docType{methods}
\name{FilesOutput}
\alias{FilesOutput}
\title{Constructor method for FilesOutput}
\usage{
FilesOutput(outResultName)
}
\value{
\code{"FilesOutput"}
}
| 265 | mit |
1f4fbaf2228d61e492e2fdf512099e10338e565c | butwhywhy/amsstats | man/NormalErrorGenerator.Rd | % Generated by roxygen2 (4.0.1): do not edit by hand
\name{NormalErrorGenerator}
\alias{NormalErrorGenerator}
\title{Generates a normal noise generator for use in \code{FakeMeasures} function.}
\usage{
NormalErrorGenerator(sigma)
}
\arguments{
\item{sigma}{Numeric. The standard deviation of the simulated normal noise.}
}
\description{
Generates a normal noise generator for use in \code{FakeMeasures} function.
}
\examples{
# Normal error distribution function for synthetic AMS measures with
# standard debiation 0.1
error.dist <- NormalErrorGenerator(0.1)
}
| 563 | mit |
4e8b4c381c3e8029c4f874fd6e81ec1f316ca9eb | mccurdyc/mrstudyr | man/select_schema_data.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/select.R
\name{select_schema_data}
\alias{select_schema_data}
\title{FUNCTION: select_schema_data}
\usage{
select_schema_data(d, s)
}
\description{
Select the data for only a specified schema.
}
| 274 | gpl-3.0 |
0f9398a942bca4404dc707a80d83dc7a1eb7d072 | cran/roxyPackage | man/archive.packages.Rd | \name{archive.packages}
\alias{archive.packages}
\title{Deal with old packages in your local repository}
\usage{
archive.packages(repo.root, to.dir = "Archive", keep = 1,
package = NULL, type = "source",
archive.root = repo.root, overwrite = FALSE,
reallyDoIt = FALSE)
}
\arguments{
\item{repo.root}{Path to the repository root, i.e., the
directory which contains the \code{src} and \code{bin}
directories. Usually this path should start with
"\code{file:///}".}
\item{to.dir}{Character string, name of the folder to
move the old packages to.}
\item{keep}{An integer value defining the maximum nuber
of versions to keep. Setting this to 0 will completely
remove all packages from the repository, which is
probably only useful in combination with the option
\code{package}.}
\item{package}{A character vector with package names to
check. If set, \code{archive.packages} will only take
actions on these packages. If \code{NULL}, all packages
are affected.}
\item{type}{A character vector defining the package
formats to keep. Valid entries are \code{"source"},
\code{"win.binary"} and \code{"mac.binary.leopard"}. By
default, only the source packages are archived, all other
packages are deleted.}
\item{archive.root}{Path to the archive root, i.e., the
directory to which files should be moved. Usually the
Archive is kept i \code{repo.root}}
\item{overwrite}{Logical, indicated whether existing
files in the archive can be overwritten.}
\item{reallyDoIt}{Logical, real actions are only taken if
set to \code{TRUE}, otherwise the actions are only
printed.}
}
\description{
Use this function to move older versions of a package to
a specified archive directory, or remove them completely.
}
\note{
This function responds to
\code{\link[roxyPackage:sandbox]{sandbox}}.
}
\examples{
\dontrun{
# dry run, only prints what would happen, so you can check
# if that's really what you want
archive.packages("file:///var/www/repo")
# after we've confirmed that the right packages will be moved
# and deleted, let's actually commit the changes
archive.packages("file:///var/www/repo", reallyDoIt=TRUE)
# if we don't want a standard archive, but for instance a parallel
# archive repository, we can have it. let's move all but the latest two
# versions from /var/www/repo to /var/www/archive. to suppress the
# creation of a special archive directory, we set to.dir=""
archive.packages("file:///var/www/repo", to.dir="", keep=2,
type=c("source", "win.binary", "mac.binary.leopard"),
archive.root="/var/www/archive", reallyDoIt=TRUE)
}
}
\seealso{
\code{\link[roxyPackage:sandbox]{sandbox}} to run
archive.packages() in a sandbox.
}
| 2,716 | gpl-3.0 |
f01dff2d73d797ce33032691bd47422d472db8b7 | matthewwolak/gremlin | man/Mrode11.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/datasets.R
\docType{data}
\name{Mrode11}
\alias{Mrode11}
\title{Weight gain data.}
\format{
An object of class \code{data.frame} with 5 rows and 5 columns.
}
\source{
Mrode, R.A. 2005. Linear Models for the Prediction of Animal Breeding
Values, 2nd ed. CABI Publishing, Cambridge, MA, USA.
}
\usage{
Mrode11
}
\description{
Data from chapter 11 in Mrode 2005. The variables are as follows:
}
\details{
\itemize{
\item calf. a factor with levels \code{4} \code{5} \code{6} \code{7} \code{8}
\item dam. a factor with levels \code{2} \code{5} \code{6}
\item sire. a factor with levels \code{1} \code{3} \code{4}
\item sex. a factor with levels \code{male} \code{female}
\item WWG11. a numeric vector
}
}
\examples{
data(Mrode11)
}
\keyword{datasets}
| 837 | gpl-3.0 |
74436a2ad9842468318ce576f1157dc1fdedd3eb | rivolli/utiml | man/predict.CLRmodel.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/method_clr.R
\name{predict.CLRmodel}
\alias{predict.CLRmodel}
\title{Predict Method for CLR}
\usage{
\method{predict}{CLRmodel}(
object,
newdata,
probability = getOption("utiml.use.probs", TRUE),
...,
cores = getOption("utiml.cores", 1),
seed = getOption("utiml.seed", NA)
)
}
\arguments{
\item{object}{Object of class '\code{CLRmodel}'.}
\item{newdata}{An object containing the new input data. This must be a
matrix, data.frame or a mldr object.}
\item{probability}{Logical indicating whether class probabilities should be
returned. (Default: \code{getOption("utiml.use.probs", TRUE)})}
\item{...}{Others arguments passed to the base algorithm prediction for all
subproblems.}
\item{cores}{The number of cores to parallelize the training. Values higher
than 1 require the \pkg{parallel} package. (Default:
\code{options("utiml.cores", 1)})}
\item{seed}{An optional integer used to set the seed. This is useful when
the method is run in parallel. (Default: \code{options("utiml.seed", NA)})}
}
\value{
An object of type mlresult, based on the parameter probability.
}
\description{
This function predicts values based upon a model trained by
\code{\link{clr}}.
}
\examples{
model <- clr(toyml, "RANDOM")
pred <- predict(model, toyml)
}
\seealso{
\code{\link[=br]{Binary Relevance (BR)}}
}
| 1,384 | gpl-2.0 |
f2a9dd845c47101859ac4bfdb81cdbee433423a8 | jasenfinch/OrbiFIEproc | man/plotPurity.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/allGenerics.R, R/plot.R
\name{plotPurity}
\alias{plotPurity}
\alias{plotPurity,Binalysis-method}
\title{Plot bin purity histogram}
\usage{
plotPurity(x, histBins = 30)
\S4method{plotPurity}{Binalysis}(x, histBins = 30)
}
\arguments{
\item{x}{S4 object of class Binalysis}
\item{histBins}{number of bins to use for histogram plotting}
}
\description{
Plot the bin purity distribution for a Binalysis object.
}
\seealso{
\code{\link{accurateData}}, \code{\link{binneRlyse}},
\code{\link{plotCentrality}}
}
| 585 | gpl-2.0 |
9d2a951355976704d6b2676de96c3a24a5956f08 | slanglab/phrasemachine | R/phrasemachine/man/coarsen_POS_tags.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/coarsen_POS_tags.R
\name{coarsen_POS_tags}
\alias{coarsen_POS_tags}
\title{Coarsen POS tags}
\usage{
coarsen_POS_tags(tag_vector)
}
\arguments{
\item{tag_vector}{A vector of POS tags.}
}
\value{
A vector of coarse tags.
}
\description{
Coarsens PTB or Petrov/Gimpel coarse tags into one of eight
categories:
'A' = adjective, 'D' = determiner, 'P' = preposition,
'N' = common/proper noun, 'M' = verb modifiers, 'V' = verbs,
'C' = coordinating conjunction, 'O' = all else
NOTE: 'M', 'C', and 'V' tags are currently only compatible with the PTB tagset.
}
\examples{
pos_tags <- c("VB", "JJ", "NN", "NN")
coarsen_POS_tags(pos_tags)
}
| 708 | mit |
280d8eadb6ecfe1805764b2f0b4d28df6bcae8ea | cran/MVR | man/target.diagnostic.Rd | \name{target.diagnostic}
\alias{target.diagnostic}
\title{Function for Plotting Summary Target Moments Diagnostic Plots}
\description{
Plot comparative distribution densities of means and standard deviations of the data before and after Mean-Variance Regularization
to check for location shifts between observed first and second moments and their expected target values under a target centered homoscedastic model.
Plot comparative QQ scatterplots to look at departures between observed distributions of first and second moments of the MVR-transformed data
and their theoretical distributions assuming independence and normality of all the variables.
}
\usage{
target.diagnostic(obj,
title = "Target Moments Diagnostic Plots",
device = NULL,
file = "Target Moments Diagnostic Plots",
path = getwd(),
horizontal = FALSE,
width = 8.5,
height = 6.5, ...)
}
\arguments{
\item{obj}{Object of class "\code{mvr}" returned by \code{\link[MVR]{mvr}}.}
\item{title}{Title of the plot. Defaults to "Target Moments Diagnostic Plots".}
\item{device}{Graphic display device in \{NULL, "PS", "PDF"\}. Defaults to NULL (standard output screen).
Currently implemented graphic display devices are "PS" (Postscript) or "PDF" (Portable Document Format).}
\item{file}{File name for output graphic. Defaults to "Target Moments Diagnostic Plots".}
\item{path}{Absolute path (without final (back)slash separator). Defaults to working directory path.}
\item{horizontal}{\code{Logical} scalar. Orientation of the printed image. Defaults to \code{FALSE}, that is potrait orientation.}
\item{width}{\code{Numeric} scalar. Width of the graphics region in inches. Defaults to 8.5.}
\item{height}{\code{Numeric} scalar. Height of the graphics region in inches. Defaults to 6.5.}
\item{\dots}{Generic arguments passed to other plotting functions.}
}
\details{
The plots of the density distribution of means and standard deviations checks that the distributions of means and standard deviations
of the MVR-transformed data have correct target first moments, i.e. with mean ~ 0 and mean ~ 1. The expected target mean and standard
deviation are shown in red (before and) after MVR-transformation. Caption shows the p-values from the parametric two-sample two-sided t-tests
for the equality of parameters to their expectations (assuming normality since usually sample sizes are large : \eqn{p \gg 1},
or a relative robustness to moderate violations of the normality assumption).
In the general case, the variables are not normally distributed and not even independent and identically distributed before
and after MVR-transformation. Therefore, the distributions of untransformed first and second moments usually differ from their respective
theoretical null distributions, i.e., from \eqn{N(0, \frac{1}{n})} for the means and from \eqn{\sqrt{\frac{\chi_{n - G}^{2}}{n - G}}} for the standard
deviations, where \eqn{G} denotes the number of sample groups (see \cite{Dazard, J-E. and J. S. Rao (2012)} for more details).
Also, the observed distributions of transformed first and second moments are unknown. This is reflected in the QQ plots,
where theoretical and empirical quantiles do not necessarily align with each other. Caption shows the p-values from the nonparametric two-sample
two-sided Kolmogorov-Smirnov tests of the null hypothesis that a parameter distribution differs from its theoretical distribution.
Each black dot represents a variable. The red solid line depicts the interquartile line, which passes through the first and third quartiles.
Option \code{file} is used only if device is specified (i.e. non \code{NULL}).
}
\value{
None. Displays the plots on the chosen \code{device}.
}
\author{
\itemize{
\item "Jean-Eudes Dazard, Ph.D." \email{[email protected]}
\item "Hua Xu, Ph.D." \email{[email protected]}
\item "Alberto Santana, MBA." \email{[email protected]}
}
Maintainer: "Jean-Eudes Dazard, Ph.D." \email{[email protected]}
}
\references{
\itemize{
\item Dazard J-E. and J. S. Rao (2010). "\emph{Regularized Variance Estimation and Variance Stabilization of High-Dimensional Data.}"
In JSM Proceedings, Section for High-Dimensional Data Analysis and Variable Selection.
Vancouver, BC, Canada: American Statistical Association IMS - JSM, 5295-5309.
\item Dazard J-E., Hua Xu and J. S. Rao (2011). "\emph{R package MVR for Joint Adaptive Mean-Variance Regularization and Variance Stabilization.}"
In JSM Proceedings, Section for Statistical Programmers and Analysts.
Miami Beach, FL, USA: American Statistical Association IMS - JSM, 3849-3863.
\item Dazard J-E. and J. S. Rao (2012). "\emph{Joint Adaptive Mean-Variance Regularization and Variance Stabilization of High Dimensional Data.}"
Comput. Statist. Data Anal. 56(7):2317-2333.
}
}
\section{Acknowledgments}{
This work made use of the High Performance Computing Resource in the Core Facility for Advanced Research Computing at Case Western Reserve University.
This project was partially funded by the National Institutes of Health (P30-CA043703).
}
\note{
End-user function.
}
\seealso{
\code{justvsn} (R package \pkg{vsn}) Variance stabilization and calibration for microarray data.
\code{loess} (R package \pkg{stats}) Fit a polynomial surface determined by one or more numerical predictors, using local fitting.
}
\examples{
\dontrun{
#===================================================
# Loading the library and its dependencies
#===================================================
library("MVR")
library("RColorBrewer")
#===================================================
# MVR package news
#===================================================
MVR.news()
#================================================
# MVR package citation
#================================================
citation("MVR")
#===================================================
# Loading of the Synthetic and Real datasets
# (see description of datasets)
#===================================================
data("Synthetic", "Real", package="MVR")
?Synthetic
?Real
#===================================================
# Mean-Variance Regularization (Real dataset)
# Multi-Group Assumption
# Assuming unequal variance between groups
# Without cluster usage
#===================================================
nc.min <- 1
nc.max <- 30
probs <- seq(0, 1, 0.01)
n <- 6
GF <- factor(gl(n = 2, k = n/2, length = n),
ordered = FALSE,
labels = c("M", "S"))
mvr.obj <- mvr(data = Real,
block = GF,
log = FALSE,
nc.min = nc.min,
nc.max = nc.max,
probs = probs,
B = 100,
parallel = FALSE,
conf = NULL,
verbose = TRUE,
seed = 1234)
#===================================================
# Summary Target Moments Diagnostic Plots (Real dataset)
# Multi-Group Assumption
# Assuming unequal variance between groups
#===================================================
target.diagnostic(obj = mvr.obj,
title = "Target Moments Diagnostic Plots
(Real - Multi-Group Assumption)",
device = NULL,
horizontal = FALSE,
width = 8.5,
height = 6.5)
}
}
\keyword{Mean-Variance Estimators}
\keyword{Regularization}
\keyword{Variance Stabilization}
\keyword{Normalization}
| 8,081 | gpl-3.0 |
2a12115eb87bf14519caa672206670cce8c1718e | radfordneal/pqR | src/library/tools/man/Rdiff.Rd | % File src/library/tools/man/Rdiff.Rd
% Part of the R package, http://www.R-project.org
% Copyright 2010-11 R Core Team
% Distributed under GPL 2 or later
\name{Rdiff}
\alias{Rdiff}
\title{Difference R Output Files}
\description{
Given two \R output files, compute differences ignoring headers,
footers and some other differences.
}
\usage{
Rdiff(from, to, useDiff = FALSE, forEx = FALSE, nullPointers = TRUE,
Log = FALSE)
}
\arguments{
\item{from, to}{filepaths to be compared}
\item{useDiff}{should \command{diff} always be used to compare
results?}
\item{forEx}{logical: extra pruning for \file{-Ex.Rout} files to
exclude the header.}
\item{nullPointers}{logical: should the displayed addresses of
pointers be set to \code{0x00000000} before comparison?}
\item{Log}{logical: should the returned value include a log of
differences found?}
}
\details{
The \R startup banner and any timing information from \command{R CMD
BATCH} are removed from both files, together with lines about loading
packages. UTF-8 fancy quotes (see \code{\link{sQuote}}) and on
Windows, Windows' so-called \sQuote{smart quotes} are mapped to a
simple quote. Addresses of environments, compiled bytecode and other
exotic types expressed as hex addresses (e.g. \code{<environment:
0x12345678>}) are mapped to \code{0x00000000}. The files are then
compared line-by-line. If there are the same number of lines and
\code{useDiff} is false, a simple \command{diff}-like display of
differences is printed, otherwise \command{diff -bw} is called on the
edited files.
As from \R 2.14.0 this can compare uncompressed PDF files, ignoring
differences in creation and modification dates.
}
\value{
If \code{Log} is true, a list with components \code{status} (see
below) and \code{out}, a character vector of descriptions of
differences, possibly of zero length.
Otherwise, a status indicator, \code{0L} if and only if no differences
were found.
}
\seealso{
The shell script run as \command{R CMD Rdiff}.
}
\keyword{utilities}
| 2,079 | gpl-2.0 |
f6d40d650d5b6c638bf0bcd7c6d8cb8a68b29c6f | bflammers/ANN2 | man/encode.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/interface.R
\name{encode}
\alias{encode}
\alias{encode.ANN}
\title{Encoding step}
\usage{
encode(object, ...)
\method{encode}{ANN}(object, newdata, compression.layer = NULL, ...)
}
\arguments{
\item{object}{Object of class \code{ANN}}
\item{\dots}{arguments to be passed down}
\item{newdata}{Data to compress}
\item{compression.layer}{Integer specifying which hidden layer is the
compression layer. If NULL this parameter is inferred from the structure
of the network (hidden layer with smallest number of nodes)}
}
\description{
Compress data according to trained replicator or autoencoder.
Outputs are the activations of the nodes in the middle layer for each
observation in \code{newdata}
}
| 779 | lgpl-3.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | Mouseomics/R | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | ArunChauhan/cxxr | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | krlmlr/cxxr | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | LeifAndersen/R | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | allr/r-instrumented | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | cxxr-devel/cxxr | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | jimhester/r-source | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | kmillar/cxxr | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | WelkinGuan/r-source | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | reactorlabs/gnur | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | wch/r-source | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | krlmlr/r-source | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | andy-thomason/r-source | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | minux/R | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
57f0bd38edf9f43a8eec1667033e46b97be55bb7 | CenterForAssessment/Literasee | man/multi_document.Rd | \name{multi_document}
\alias{multi_document}
\title{Formatter wrapper for \code{rmarkdown::html_document} to facilitate multiple output format porting.}
\usage{
multi_document(
...,
number_sections = TRUE,
number_section_depth=3,
toc = TRUE,
toc_depth = 2,
self_contained = TRUE,
dev = "png",
literasee_template = "sgp_report",
html_template = "default",
css = "default",
bibliography = "default",
csl = "default",
md_extensions=NULL,
pandoc_args = NULL)
}
\arguments{
\item{...}{Passed onto \code{\link[rmarkdown]{html_document}}.}
\item{number_sections}{Boolean. Should sections, subsections, and subsubsections be numbered. Default \code{TRUE}}
\item{number_section_depth}{Numeric. Depth of headers to include in section numbering. Default is 3 (subsubsections).}
\item{toc}{Boolean. \code{TRUE} to include a table of contents in the output}
\item{toc_depth}{Numeric. Depth of headers to include in table of
contents. Default is 2 (subsections).}
\item{self_contained}{Produce a standalone HTML file with no external dependencies, using data:
URIs to incorporate the contents of linked scripts, stylesheets, images, and videos.}
\item{dev}{Graphics device to use for figure output (defaults to png).}
\item{literasee_template}{Name of Literasee package style template to use for rendering. Default is \sQuote{sgp_report}
(currently the only option available). Located at \code{system.file('rmarkdown', 'templates', 'sgp_report', 'resources', package = 'Literasee')}.
Note that alternative templates must adopt the same naming conventions (\sQuote{html_report.html}, \sQuote{pdf_report.tex}, etc).}
\item{html_template}{Pandoc HTML template to use for rendering. Pass \code{"default"} to use the Literasee package default
template. Note that if you do not use the default template then the features of \code{multi_document} will not be available.}
\item{css}{The CSS if other that the default within the package.}
\item{bibliography}{The LaTeX style bibliography file (.bib, .bibtex, etc.) to include. The default file included
in the package includes references often used by the author and will likely be insufficient for most users.}
\item{csl}{The CSL (citation style language) to use to format bibliography (if included). Defaults to APA 5th edition. See
\href{https://github.com/citation-style-language/styles}{this Github repository} for alternatives.
If NULL pandoc defaults will be used.}
\item{md_extensions}{Markdown extensions to be added or removed from the default definition or R Markdown.}
\item{pandoc_args}{Additional command line options to pass to pandoc}
}
\value{
R Markdown output format to pass to \code{\link[rmarkdown]{render}}
}
\description{
This function produces a markdown file suitable for rendering as a
stylized, standalone HTML document tailored for academic and technical
reports, as well as alternative output formats. Available formats
include PDF, EPUB and DOCX.
The DOCX format is an adaptation of the \code{\link[Gmisc]{docx_document}}
processor which allows for seamless integration for importing
html-documents in the MS Word .docx-format. The advantage of html
documents is the ability to create advanced formatting
frequently needed in medical publications and that is
available in the \code{\link[htmlTable]{htmlTable}} function.
You can view
\href{http://gforge.se/2014-07/fast-track-publishing-using-rmarkdown}{the
series} for more details regarding how to achieve
fast-track-publishing (ftp) together with knitr.
}
\examples{
\dontrun{
## Produce HTML document from My_Report.Rmd
render("My_Report.Rmd",
multi_document(pandoc_args = "--webtex"))
}
}
| 3,725 | lgpl-3.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | RevolutionAnalytics/RRO | R-src/src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | SurajGupta/r-source | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | jeroenooms/r-source | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | kmillar/rho | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | rho-devel/rho | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
b5309cba9cc9c0d02b497b4a7416dc0724a31861 | ashander/phenoecosim | man/Va.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/RcppExports.R
\name{Va}
\alias{Va}
\title{Va additive genetic variance in the phenotype as a function of the environment}
\usage{
Va(env, GG)
}
\arguments{
\item{env}{environment in which plastiicty is cued}
\item{GG}{additive genetic variance-covariance matrix}
}
\description{
Va additive genetic variance in the phenotype as a function of the environment
}
| 440 | mit |
8c0e32d507ce6a217b6adf753c751e6520924223 | allr/timeR | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | aviralg/R-dyntrace | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | mathematicalcoffee/r-source | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | MouseGenomics/R | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | abiyug/r-source | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | SensePlatform/R | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
8c0e32d507ce6a217b6adf753c751e6520924223 | nathan-russell/r-source | src/library/base/man/Internal.Rd | % File src/library/base/man/Internal.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{Internal}
\alias{.Internal}
\description{
\code{.Internal} performs a call to an internal code
which is built in to the \R interpreter.
Only true \R wizards should even consider using this function, and only
\R developers can add to the list of internal functions.
}
\title{Call an Internal Function}
\usage{
.Internal(call)
}
\arguments{
\item{call}{a call expression}
}
\seealso{
\code{\link{.Primitive}}, \code{\link{.External}} (the nearest
equivalent available to users).
}
\keyword{interface}
| 675 | gpl-2.0 |
57f0bd38edf9f43a8eec1667033e46b97be55bb7 | dbetebenner/Literasee | man/multi_document.Rd | \name{multi_document}
\alias{multi_document}
\title{Formatter wrapper for \code{rmarkdown::html_document} to facilitate multiple output format porting.}
\usage{
multi_document(
...,
number_sections = TRUE,
number_section_depth=3,
toc = TRUE,
toc_depth = 2,
self_contained = TRUE,
dev = "png",
literasee_template = "sgp_report",
html_template = "default",
css = "default",
bibliography = "default",
csl = "default",
md_extensions=NULL,
pandoc_args = NULL)
}
\arguments{
\item{...}{Passed onto \code{\link[rmarkdown]{html_document}}.}
\item{number_sections}{Boolean. Should sections, subsections, and subsubsections be numbered. Default \code{TRUE}}
\item{number_section_depth}{Numeric. Depth of headers to include in section numbering. Default is 3 (subsubsections).}
\item{toc}{Boolean. \code{TRUE} to include a table of contents in the output}
\item{toc_depth}{Numeric. Depth of headers to include in table of
contents. Default is 2 (subsections).}
\item{self_contained}{Produce a standalone HTML file with no external dependencies, using data:
URIs to incorporate the contents of linked scripts, stylesheets, images, and videos.}
\item{dev}{Graphics device to use for figure output (defaults to png).}
\item{literasee_template}{Name of Literasee package style template to use for rendering. Default is \sQuote{sgp_report}
(currently the only option available). Located at \code{system.file('rmarkdown', 'templates', 'sgp_report', 'resources', package = 'Literasee')}.
Note that alternative templates must adopt the same naming conventions (\sQuote{html_report.html}, \sQuote{pdf_report.tex}, etc).}
\item{html_template}{Pandoc HTML template to use for rendering. Pass \code{"default"} to use the Literasee package default
template. Note that if you do not use the default template then the features of \code{multi_document} will not be available.}
\item{css}{The CSS if other that the default within the package.}
\item{bibliography}{The LaTeX style bibliography file (.bib, .bibtex, etc.) to include. The default file included
in the package includes references often used by the author and will likely be insufficient for most users.}
\item{csl}{The CSL (citation style language) to use to format bibliography (if included). Defaults to APA 5th edition. See
\href{https://github.com/citation-style-language/styles}{this Github repository} for alternatives.
If NULL pandoc defaults will be used.}
\item{md_extensions}{Markdown extensions to be added or removed from the default definition or R Markdown.}
\item{pandoc_args}{Additional command line options to pass to pandoc}
}
\value{
R Markdown output format to pass to \code{\link[rmarkdown]{render}}
}
\description{
This function produces a markdown file suitable for rendering as a
stylized, standalone HTML document tailored for academic and technical
reports, as well as alternative output formats. Available formats
include PDF, EPUB and DOCX.
The DOCX format is an adaptation of the \code{\link[Gmisc]{docx_document}}
processor which allows for seamless integration for importing
html-documents in the MS Word .docx-format. The advantage of html
documents is the ability to create advanced formatting
frequently needed in medical publications and that is
available in the \code{\link[htmlTable]{htmlTable}} function.
You can view
\href{http://gforge.se/2014-07/fast-track-publishing-using-rmarkdown}{the
series} for more details regarding how to achieve
fast-track-publishing (ftp) together with knitr.
}
\examples{
\dontrun{
## Produce HTML document from My_Report.Rmd
render("My_Report.Rmd",
multi_document(pandoc_args = "--webtex"))
}
}
| 3,725 | lgpl-3.0 |
8c8ba56cdead4fb01be4061790e6846f7abaa2eb | ketanmd/futacc | man/xg.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/myacc.R
\name{xg}
\alias{xg}
\title{compute cumulative statistics}
\usage{
xg(xa, byfields)
}
\arguments{
\item{xa}{input data frame}
\item{byfields}{comma separated string values}
}
\description{
compute cumulative statistics
}
| 308 | gpl-3.0 |
e476bcc807ae12a938a5d843fb74ae1e2e014566 | nplatonov/rmap | man/panel_plot.Rd | \name{panel_plot}
\alias{panel_plot}
\alias{panel_box}
\alias{panel_lines}
\alias{panel_points}
\alias{panel_text}
\alias{panel_abline}
\alias{panel_polygon}
\alias{panel_segments}
%- Also NEED an '\alias' for EACH other topic documented here.
\title{
Add graphical elements to the image panel
}
\description{
Standard fuctions for plotting from package \pkg{graphics} are used for manual adding elements to current plot. Theses series of functions used that standard instruments with additional controling the acceptability of plotting.
}
\usage{
panel_plot(obj,...)
panel_box(...)
panel_lines(...)
panel_points(...)
panel_text(...)
panel_abline(...)
panel_polygon(...)
panel_segments(...)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{obj}{\R object.}
\item{\dots}{
%% ~~Describe \code{\dots} here~~
In \code{panel_plot} arguments are passed to function \code{\link[graphics:plot.default]{plot}}.\cr
In \code{panel_box} arguments are passed to function \code{\link[graphics]{box}}.\cr
In \code{panel_lines} arguments are passed to function \code{\link[graphics]{lines}}.\cr
In \code{panel_points} arguments are passed to function \code{\link[graphics]{points}}.\cr
In \code{panel_text} arguments are passed to function \code{\link[graphics]{text}}.\cr
In \code{panel_abline} arguments are passed to function \code{\link[graphics]{abline}}.\cr
In \code{panel_polygon} arguments are passed to function \code{\link[graphics]{polygon}}.\cr
In \code{panel_segments} arguments are passed to function \code{\link[graphics]{segments}}.\cr
}
}
\details{
If unable to get value \code{TRUE} from \code{getOption("ursaPngPlot")} then plotting is disable, and any function from this series returns \code{NULL}.
Generally, for spatial objects argument \code{add=TRUE} is used in \code{panel_plot}.
%%~ If object of class \code{ursaRaster} is found among arguments of function \code{panel_contour}, then this object is converted to a suitable list \code{\link[ursa:classRaster_as.matrix]{as.matrix(obj,coords=TRUE)}}, and argument \code{add} for function \code{\link[graphics]{contour}} is forced to value \code{TRUE}.
}
\value{
For spatial objects (simple features from \pkg{sf} or spatial abstract classes from \pkg{sp}) function \code{panel_plot} returns object of class \code{ursaLegend}. It is a list with items, which can be used to as arguments of \code{\link[graphics:legend]{legend()}}. This is intermediate step for experimental feature (not ready) to display colorbars on plot panel. For other objects function \code{panel_plot} returns value of function \code{\link[graphics:plot.default]{plot}}.
Function \code{panel_box} returns value of function \code{\link[graphics]{box}}.\cr
Function \code{panel_lines} returns value of function \code{\link[graphics]{lines}}.\cr
Function \code{panel_points} returns value of function \code{\link[graphics]{points}}.\cr
Function \code{panel_text} returns value of function \code{\link[graphics]{text}}.\cr
Function \code{panel_abline} returns value of function \code{\link[graphics]{abline}}.\cr
Function \code{panel_polygon} returns value of function \code{\link[graphics]{polygon}}.\cr
Function \code{panel_segments} returns value of function \code{\link[graphics]{segments}}.\cr
}
%%~ \references{
%%~ %% ~put references to the literature/web site here ~
%%~ }
\author{
Nikita Platonov \email{[email protected]}
}
\note{
For plotted elements it is possible to create legend for colors using color bars. No shapes kind and size, no line widths.
To convert object \code{x} of class \code{ursaLegend} to object of class \code{ursaColorTable} please use \code{ursa_colortable(x)}.
}
%% ~Make other sections like Warning with \section{Warning }{....} ~
\seealso{
\code{\link[ursa:panel_contour]{panel_contour}}
%% ~~objects to See Also as \code{\link{help}}, ~~~
Package \pkg{graphics} (\code{help(package="graphics")}) and functions \code{\link[graphics:plot.default]{plot}}, \code{\link[graphics]{box}}, \code{\link[graphics]{lines}}, \code{\link[graphics]{points}}, \code{\link[graphics]{text}}, \code{\link[graphics]{abline}}, \code{\link[graphics]{polygon}}, \code{\link[graphics]{segments}}.
}
\examples{
session_grid(NULL)
require(rgdal)
a <- pixelsize()
g1 <- session_grid()
n <- 12L
k <- 5L
x <- with(g1,runif(n,min=minx,max=maxx))
y <- with(g1,runif(n,min=miny,max=maxy))
panel_plot(x,y) ## plots nothing, because 'compose_open(...,dev=F)' is not called yet
sl <- lapply(seq(k),function(id){
x <- sort(with(g1,runif(n,min=minx,max=maxx)))
y <- sort(with(g1,runif(n,min=miny,max=maxy)))
sp::Lines(sp::Line(cbind(x,y)),ID=id)
})
sl <- sp::SpatialLines(sl,proj4string=sp::CRS(ursa_proj(g1)))#,id=length(sl))
lab <- t(sapply(sp::coordinates(sl),function(xy) xy[[1]][round(n/2),]))
lab <- as.data.frame(cbind(lab,z=seq(k)))
sl <- sp::SpatialLinesDataFrame(sl
,data=data.frame(ID=runif(k,min=5,max=9),desc=LETTERS[seq(k)]))
print(sl@data)
ct <- colorize(sl@data$ID)#,name=sldf@data$desc)
shpname <- tempfile(pattern = "___tmp",tmpdir=".",fileext=".shp")
layername <- gsub("\\\\.shp$","",basename(shpname))
try(writeOGR(sl,dirname(shpname),layername,driver="ESRI Shapefile"))
compose_open(layout=c(1,2),legend=list(list("bottom",2)))
panel_new()
panel_decor()
panel_lines(x,y,col="orange")
panel_points(x,y,cex=5,pch=21,col="transparent",bg="#00FF005F")
panel_points(0,0,pch=3)
panel_text(0,0,"North\nPole",pos=4,cex=1.5,family="Courier New",font=3)
panel_new()
panel_decor()
panel_plot(sl,lwd=4,col="grey20")
if (file.exists(shpname))
panel_plot(shpname,lwd=3,col=ct$colortable[ct$index])
panel_points(lab$x,lab$y,pch=as.character(lab$z),cex=2)
compose_legend(ct$colortable)
compose_close()
file.remove(dir(path=dirname(shpname)
,pattern=paste0(layername,"\\\\.(cpg|dbf|prj|shp|shx)")
,full.names=TRUE))
}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
\keyword{aplot}
| 5,983 | gpl-2.0 |
1c43195d0dc1663c8b4b0358259aecd4bf53c017 | raymondben/datavolley | man/dv_heatmap.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/plot_base.R
\name{dv_heatmap}
\alias{dv_heatmap}
\title{Plot a court heatmap, using base graphics}
\usage{
dv_heatmap(
x,
y,
z,
col,
zlim,
legend = TRUE,
legend_title = NULL,
legend_title_font = 1,
legend_title_cex = 0.7,
legend_cex = 0.7,
legend_pos = c(0.8, 0.85, 0.25, 0.75),
res,
add = FALSE
)
}
\arguments{
\item{x}{numeric, RasterLayer or data.frame: x-coordinates of the data to plot, or a \code{RasterLayer} layer or \code{data.frame} containing the data (x, y, and z together)}
\item{y}{numeric: y-coordinates of the data to plot}
\item{z}{numeric: values of the data to plot}
\item{col}{character: a vector of colours to use}
\item{zlim}{numeric: the minimum and maximum z values for which colors should be plotted, defaulting to the range of the finite values of z}
\item{legend}{logical: if \code{TRUE}, plot a legend}
\item{legend_title}{string: title for the legend}
\item{legend_title_font}{numeric: 1 = normal, 2 = bold, 3 = italic}
\item{legend_title_cex}{numeric: size scaling of legend title}
\item{legend_cex}{numeric: size scaling of legend text}
\item{legend_pos}{numeric: position of the legend (xmin, xmax, ymin, ymax) - in normalized units}
\item{res}{numeric: size of the heatmap cells. This parameter should only be needed in cases where the input data are sparse, when the automatic algorithm can't work it out. Values are given in metres, so \code{res} is 3 when showing zones, or 1.5 when showing subzones}
\item{add}{logical: if \code{TRUE}, add the heatmap to an existing plot}
}
\description{
See \code{link{ggcourt}} for a \code{ggplot2}-based court diagram, which can be used to plot heatmaps with e.g. \code{ggplot2::geom_tile}.
}
\details{
Data can be provided either as separate \code{x}, \code{y}, and \code{z} objects, or as a single \code{RasterLayer} or \code{data.frame} object. If a \code{data.frame}, the first three columns are used (and assumed to be in the order \code{x}, \code{y}, \code{z}).
}
\examples{
\dontrun{
x <- read_dv(dv_example_file(), insert_technical_timeouts=FALSE)
library(dplyr)
## Example: attack frequency by zone, per team
attack_rate <- plays(x) \%>\% dplyr::filter(skill == "Attack") \%>\%
group_by(team, start_zone) \%>\% dplyr::summarize(n_attacks = n()) \%>\%
mutate(rate = n_attacks/sum(n_attacks)) \%>\% ungroup
## add columns "x" and "y" for the x,y coordinates associated with the zones
attack_rate <- cbind(attack_rate, dv_xy(attack_rate$start_zone, end = "lower"))
## for team 2, these need to be on the top half of the diagram
tm2 <- attack_rate$team == teams(x)[2]
attack_rate[tm2, c("x", "y")] <- dv_xy(attack_rate$start_zone, end="upper")[tm2, ]
## plot it
dv_heatmap(attack_rate[, c("x", "y", "rate")], legend_title = "Attack rate")
## or, controlling the z-limits
dv_heatmap(attack_rate[, c("x", "y", "rate")], legend_title = "Attack rate", zlim = c(0, 1))
## add the court diagram
dv_court(labels = teams(x))
## sometimes you may need more control over the plot layout
## set up a plot with 10\% bottom/top margins and 20\% left/right margins
## showing the lower half of the court only
dv_plot_new(margins = c(0.05, 0.1, 0.05, 0.1), court = "lower")
## add the heatmap
dv_heatmap(attack_rate[1:6, c("x", "y", "rate")], add = TRUE)
## and the court diagram
dv_court(court = "lower")
}
}
\seealso{
\code{\link{dv_court}}, \code{\link{dv_plot_new}}
}
| 3,467 | mit |
0579798a01351e1769bbe3ab1818444a1cbc3df4 | paultcochrane/rbokeh | man/ly_wedge.Rd | % Generated by roxygen2 (4.1.1): do not edit by hand
% Please edit documentation in R/layer_glyphs.R
\name{ly_wedge}
\alias{ly_wedge}
\title{Add a "wedge" layer to a Bokeh figure}
\usage{
ly_wedge(fig, x, y = NULL, data = NULL, radius = 0.3, start_angle = 0,
end_angle = 2 * pi, direction = "anticlock", color = NULL, alpha = 1,
hover = NULL, url = NULL, legend = NULL, lname = NULL,
lgroup = NULL, ...)
}
\arguments{
\item{fig}{figure to modify}
\item{x}{values or field name of center x coordinates}
\item{y}{values or field name of center y coordinates}
\item{data}{an optional data frame, providing the source for inputs x, y, and other glyph properties}
\item{radius}{values or field name of wedge radii}
\item{start_angle}{the angles to start the wedges, in radians, as measured from the horizontal}
\item{end_angle}{the angles to end the wedges, in radians, as measured from the horizontal}
\item{direction}{direction to turn between starting and ending angles ("anticlock", "clock")}
\item{color}{color for the glyph - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' - for glyphs with both fill and line properties, see "Handling color" below}
\item{alpha}{the alpha transparency of the glyph between 0 (transparent) and 1 (opaque) - if glyph has both fill and color properties, see "Handling alpha" below}
\item{hover}{a data frame of variables to be displayed when hovering over the glyph or a vector of variable names that can be found and extracted from the \code{data} argument}
\item{url}{a string of URLs or a single string that references a variable name (via @var_name) that can be found and extracted from the \code{data} argument}
\item{legend}{either a logical specifying not to plot a legend for this layer (FALSE) or a string indicating the name of the legend entry for this layer (note that when mapping plot attributes to variables in \code{data}, a legend is automatically created and does not need to be specified - see "Mapped plot attributes and legends" below)}
\item{lname}{layer name}
\item{lgroup}{layer group}
\item{\ldots}{additional parameters for fine control over fill and line properties (see "Additional parameters" below)}
}
\description{
Add a "wedge" layer to a Bokeh figure
}
\section{Handling color}{
The \code{color} parameter is a high-level plot attribute that provides default behavior for coloring glyphs.
\itemize{
\item When using a glyph that only has line properties, this will be the color of the line.
\item When using a glyph that has has line and fill properties, this will be the color of the line and the fill, with the alpha level of the fill reduced by 50\%.
\item If full control over fill and line color is desired, the \code{fill_color} and \code{line_color} attributes can be specified explicitly and will override \code{color}.
}
When color is \code{NULL} and \code{fill_color} or \code{line_color} are not specified, the color will be chosen from the theme.
}
\section{Handling alpha}{
The \code{alpha} is a high-level plot attribute that sets the transparency of the glyph being plotted.
\itemize{
\item When using a glyph that only has line properties, this will be the alpha of the line.
\item When using a glyph that has has line and fill properties, this will be the alpha of the line and the alpha of the fill will be set to 50\% of this value.
\item Individual fill and line alpha can be specified with \code{fill_alpha} and \code{line_alpha} and will override \code{alpha}.
}
}
\section{Mapped plot attributes and legends}{
When specifying an input data frame for a layer through the \code{data} argument, columns of \code{data} can be used to specify various plot attributes such as \code{color}, etc. For example, with \code{ly_points(..., data = iris, color = Species)}, the \code{Species} variable is used to determine how to color the points. Here, \code{Species} is "mapped" to the \code{color} attribute. Both continuous and categorical variables can be mapped. In the case of continuous variables, the range is cut into slices and attributes are applied to each interval. The mapping from the values of the variable to the actual plot attributes is determined based on the theme.
}
\section{Additional parameters}{
\tabular{ll}{
\code{fill_color} \tab color to use to fill the glyph with - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' \cr
\code{fill_alpha} \tab transparency value between 0 (transparent) and 1 (opaque) \cr
\code{line_color} \tab color to use to stroke lines with - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' \cr
\code{line_width} \tab stroke width in units of pixels \cr
\code{line_alpha} \tab transparency value between 0 (transparent) and 1 (opaque) \cr
\code{line_join} \tab how path segments should be joined together 'miter' 'round' 'bevel' \cr
\code{line_cap} \tab how path segments should be terminated 'butt' 'round' 'square' \cr
\code{line_dash} \tab array of integer pixel distances that describe the on-off pattern of dashing to use \cr
\code{line_dash_offset} \tab the distance in pixels into the line_dash that the pattern should start from
}
}
\examples{
\donttest{
rescale <- function(x)
(x - min(x)) / diff(range(x))
figure() \%>\%
ly_annular_wedge(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
inner_radius = 0.1, outer_radius = 0.15, alpha = 0.5,
hover = Species)
figure() \%>\%
ly_wedge(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
radius = 0.15, alpha = 0.5,
hover = Species)
figure() \%>\%
ly_arc(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
alpha = 0.5)
figure() \%>\%
ly_annulus(Sepal.Length, Sepal.Width, data = iris,
color = Species, hover = Species,
outer_radius = rescale(Petal.Length) * 0.3,
inner_radius = rescale(Petal.Length) * 0.1)
}
}
\seealso{
Other layer functions: \code{\link{ly_abline}};
\code{\link{ly_annular_wedge}}; \code{\link{ly_annulus}};
\code{\link{ly_arc}}; \code{\link{ly_bezier}};
\code{\link{ly_boxplot}}; \code{\link{ly_contour}};
\code{\link{ly_crect}}; \code{\link{ly_curve}};
\code{\link{ly_density}}; \code{\link{ly_hist}};
\code{\link{ly_image_url}}; \code{\link{ly_image}};
\code{\link{ly_lines}}; \code{\link{ly_map}};
\code{\link{ly_multi_line}}; \code{\link{ly_oval}};
\code{\link{ly_patch}}; \code{\link{ly_points}};
\code{\link{ly_polygons}}; \code{\link{ly_quadratic}};
\code{\link{ly_quantile}}; \code{\link{ly_ray}};
\code{\link{ly_rect}}; \code{\link{ly_segments}};
\code{\link{ly_text}}
}
| 6,780 | mit |
670276b6379b32eafa960e5877f928a8c6fc098e | bnaras/cvxr | man/id.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/generics.R
\docType{methods}
\name{id}
\alias{id}
\title{Identification Number}
\usage{
id(object)
}
\arguments{
\item{object}{A \linkS4class{Variable} or \linkS4class{Constraint} object.}
}
\value{
A non-negative integer identifier.
}
\description{
A unique identification number used internally to keep track of variables and constraints. Should not be modified by the user.
}
\examples{
x <- Variable()
constr <- (x >= 5)
id(x)
id(constr)
}
\seealso{
\code{\link[CVXR]{get_id}} \code{\link[CVXR]{setIdCounter}}
}
| 594 | gpl-2.0 |
266ca225654946f028612d766027aeda471d8650 | Arroita/streamMetabolizer | man/load_french_creek_std.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/load_french_creek_std.R
\name{load_french_creek_std}
\alias{load_french_creek_std}
\title{Load a short dataset from French Creek using Bob Hall's code}
\usage{
load_french_creek_std(attach.units = TRUE)
}
\arguments{
\item{attach.units}{logical. Should units be attached to the data.frame?}
}
\value{
a data.frame, unitted if attach.units==TRUE
}
\description{
This function requires \code{chron}, a package that is not formally required
by the \code{streamMetabolizer} package overall. Ensure that you have
\code{chron} installed or install it with \code{install.packages('chron')}.
}
\details{
This function produces a version of the French Creek dataset that agrees as
much as possible with raw code from Bob Hall, for comparison to functions
written in streamMetabolizer. Line numbers in comments (L22, etc.) refer to
those in 'stream_metab_usa/starter_files/One station metab code.R'
}
| 973 | cc0-1.0 |
0579798a01351e1769bbe3ab1818444a1cbc3df4 | sinhrks/rbokeh | man/ly_wedge.Rd | % Generated by roxygen2 (4.1.1): do not edit by hand
% Please edit documentation in R/layer_glyphs.R
\name{ly_wedge}
\alias{ly_wedge}
\title{Add a "wedge" layer to a Bokeh figure}
\usage{
ly_wedge(fig, x, y = NULL, data = NULL, radius = 0.3, start_angle = 0,
end_angle = 2 * pi, direction = "anticlock", color = NULL, alpha = 1,
hover = NULL, url = NULL, legend = NULL, lname = NULL,
lgroup = NULL, ...)
}
\arguments{
\item{fig}{figure to modify}
\item{x}{values or field name of center x coordinates}
\item{y}{values or field name of center y coordinates}
\item{data}{an optional data frame, providing the source for inputs x, y, and other glyph properties}
\item{radius}{values or field name of wedge radii}
\item{start_angle}{the angles to start the wedges, in radians, as measured from the horizontal}
\item{end_angle}{the angles to end the wedges, in radians, as measured from the horizontal}
\item{direction}{direction to turn between starting and ending angles ("anticlock", "clock")}
\item{color}{color for the glyph - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' - for glyphs with both fill and line properties, see "Handling color" below}
\item{alpha}{the alpha transparency of the glyph between 0 (transparent) and 1 (opaque) - if glyph has both fill and color properties, see "Handling alpha" below}
\item{hover}{a data frame of variables to be displayed when hovering over the glyph or a vector of variable names that can be found and extracted from the \code{data} argument}
\item{url}{a string of URLs or a single string that references a variable name (via @var_name) that can be found and extracted from the \code{data} argument}
\item{legend}{either a logical specifying not to plot a legend for this layer (FALSE) or a string indicating the name of the legend entry for this layer (note that when mapping plot attributes to variables in \code{data}, a legend is automatically created and does not need to be specified - see "Mapped plot attributes and legends" below)}
\item{lname}{layer name}
\item{lgroup}{layer group}
\item{\ldots}{additional parameters for fine control over fill and line properties (see "Additional parameters" below)}
}
\description{
Add a "wedge" layer to a Bokeh figure
}
\section{Handling color}{
The \code{color} parameter is a high-level plot attribute that provides default behavior for coloring glyphs.
\itemize{
\item When using a glyph that only has line properties, this will be the color of the line.
\item When using a glyph that has has line and fill properties, this will be the color of the line and the fill, with the alpha level of the fill reduced by 50\%.
\item If full control over fill and line color is desired, the \code{fill_color} and \code{line_color} attributes can be specified explicitly and will override \code{color}.
}
When color is \code{NULL} and \code{fill_color} or \code{line_color} are not specified, the color will be chosen from the theme.
}
\section{Handling alpha}{
The \code{alpha} is a high-level plot attribute that sets the transparency of the glyph being plotted.
\itemize{
\item When using a glyph that only has line properties, this will be the alpha of the line.
\item When using a glyph that has has line and fill properties, this will be the alpha of the line and the alpha of the fill will be set to 50\% of this value.
\item Individual fill and line alpha can be specified with \code{fill_alpha} and \code{line_alpha} and will override \code{alpha}.
}
}
\section{Mapped plot attributes and legends}{
When specifying an input data frame for a layer through the \code{data} argument, columns of \code{data} can be used to specify various plot attributes such as \code{color}, etc. For example, with \code{ly_points(..., data = iris, color = Species)}, the \code{Species} variable is used to determine how to color the points. Here, \code{Species} is "mapped" to the \code{color} attribute. Both continuous and categorical variables can be mapped. In the case of continuous variables, the range is cut into slices and attributes are applied to each interval. The mapping from the values of the variable to the actual plot attributes is determined based on the theme.
}
\section{Additional parameters}{
\tabular{ll}{
\code{fill_color} \tab color to use to fill the glyph with - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' \cr
\code{fill_alpha} \tab transparency value between 0 (transparent) and 1 (opaque) \cr
\code{line_color} \tab color to use to stroke lines with - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' \cr
\code{line_width} \tab stroke width in units of pixels \cr
\code{line_alpha} \tab transparency value between 0 (transparent) and 1 (opaque) \cr
\code{line_join} \tab how path segments should be joined together 'miter' 'round' 'bevel' \cr
\code{line_cap} \tab how path segments should be terminated 'butt' 'round' 'square' \cr
\code{line_dash} \tab array of integer pixel distances that describe the on-off pattern of dashing to use \cr
\code{line_dash_offset} \tab the distance in pixels into the line_dash that the pattern should start from
}
}
\examples{
\donttest{
rescale <- function(x)
(x - min(x)) / diff(range(x))
figure() \%>\%
ly_annular_wedge(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
inner_radius = 0.1, outer_radius = 0.15, alpha = 0.5,
hover = Species)
figure() \%>\%
ly_wedge(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
radius = 0.15, alpha = 0.5,
hover = Species)
figure() \%>\%
ly_arc(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
alpha = 0.5)
figure() \%>\%
ly_annulus(Sepal.Length, Sepal.Width, data = iris,
color = Species, hover = Species,
outer_radius = rescale(Petal.Length) * 0.3,
inner_radius = rescale(Petal.Length) * 0.1)
}
}
\seealso{
Other layer functions: \code{\link{ly_abline}};
\code{\link{ly_annular_wedge}}; \code{\link{ly_annulus}};
\code{\link{ly_arc}}; \code{\link{ly_bezier}};
\code{\link{ly_boxplot}}; \code{\link{ly_contour}};
\code{\link{ly_crect}}; \code{\link{ly_curve}};
\code{\link{ly_density}}; \code{\link{ly_hist}};
\code{\link{ly_image_url}}; \code{\link{ly_image}};
\code{\link{ly_lines}}; \code{\link{ly_map}};
\code{\link{ly_multi_line}}; \code{\link{ly_oval}};
\code{\link{ly_patch}}; \code{\link{ly_points}};
\code{\link{ly_polygons}}; \code{\link{ly_quadratic}};
\code{\link{ly_quantile}}; \code{\link{ly_ray}};
\code{\link{ly_rect}}; \code{\link{ly_segments}};
\code{\link{ly_text}}
}
| 6,780 | mit |
670276b6379b32eafa960e5877f928a8c6fc098e | anqif/cvxr | man/id.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/generics.R
\docType{methods}
\name{id}
\alias{id}
\title{Identification Number}
\usage{
id(object)
}
\arguments{
\item{object}{A \linkS4class{Variable} or \linkS4class{Constraint} object.}
}
\value{
A non-negative integer identifier.
}
\description{
A unique identification number used internally to keep track of variables and constraints. Should not be modified by the user.
}
\examples{
x <- Variable()
constr <- (x >= 5)
id(x)
id(constr)
}
\seealso{
\code{\link[CVXR]{get_id}} \code{\link[CVXR]{setIdCounter}}
}
| 594 | apache-2.0 |
c19c1695e56ce59ce479b2aa6a5318a4276613a7 | ibn-salem/chromloop | man/addInteractionSupport.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/interaction.R
\name{addInteractionSupport}
\alias{addInteractionSupport}
\title{Add column to \code{\link{GInteractions}} with overlap support.}
\usage{
addInteractionSupport(gi, subject, colname = "loop", ...)
}
\arguments{
\item{gi}{\code{\link{GInteractions}} object}
\item{subject}{another \code{\link{GInteractions}} object}
\item{colname}{name of the new annotation column in \code{gi}.}
\item{...}{additional arguments passed to \code{\link[IRanges:findOverlaps-methods]{overlapsAny}}.}
}
\value{
\code{\link{InteractionSet}} \code{gi} as input but with additional
annotation column \code{colname} indicating whether each interaction
is supported by \code{subject} or not.
}
\description{
See overlap methods in \code{\link{InteractionSet}} package for more details
on the overlap calculations: \code{?overlapsAny}
}
\examples{
# build example GRanges as anchors
anchorGR <- GRanges(
rep("chr1", 4),
IRanges(
c(1, 5, 20, 14),
c(4, 8, 23, 17)
),
strand = c("+", "+", "+", "-"),
score = c(5, 4, 6, 7)
)
# build example GIntreaction object
gi <- GInteractions(
c(1, 2, 2),
c(4, 3, 4),
anchorGR,
mode = "strict"
)
# build exapple support GInteractions object
exampleSupport <- GInteractions(
GRanges("chr1", IRanges(1, 4)),
GRanges("chr1", IRanges(15, 20))
)
# add support
gi <- addInteractionSupport(gi, subject = exampleSupport)
# Use colname argument to add support to differnt metadata column name
gi <- addInteractionSupport(gi, subject = exampleSupport, colname = "example")
}
| 1,601 | gpl-3.0 |
9c9d1d44c5c4770796768efe7506a41db8e31680 | ClaraHapp/funData | man/as.multiFunData.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/funDataClass.R
\name{as.multiFunData}
\alias{as.multiFunData}
\alias{as.multiFunData,funData-method}
\title{Coerce a funData object to class multiFunData}
\usage{
as.multiFunData(object)
\S4method{as.multiFunData}{funData}(object)
}
\arguments{
\item{object}{The \code{funData} object that is to be converted to a
\code{multiFunData} object of length 1.}
}
\description{
Coerce a \code{funData} object to class \code{multiFunData} with one element.
}
\examples{
# create funData object with 5 observations
x <- seq(0,1,0.01)
f1 <- funData(argvals = x, X = 1:5 \%o\% x)
f1
class(f1)
# coerce to multiFunData object (of length 1)
m1 <- as.multiFunData(f1)
m1
class(m1)
}
\seealso{
\code{\linkS4class{funData}}, \code{\linkS4class{multiFunData}}
}
| 825 | gpl-2.0 |
0579798a01351e1769bbe3ab1818444a1cbc3df4 | timelyportfolio/rBokeh | man/ly_wedge.Rd | % Generated by roxygen2 (4.1.1): do not edit by hand
% Please edit documentation in R/layer_glyphs.R
\name{ly_wedge}
\alias{ly_wedge}
\title{Add a "wedge" layer to a Bokeh figure}
\usage{
ly_wedge(fig, x, y = NULL, data = NULL, radius = 0.3, start_angle = 0,
end_angle = 2 * pi, direction = "anticlock", color = NULL, alpha = 1,
hover = NULL, url = NULL, legend = NULL, lname = NULL,
lgroup = NULL, ...)
}
\arguments{
\item{fig}{figure to modify}
\item{x}{values or field name of center x coordinates}
\item{y}{values or field name of center y coordinates}
\item{data}{an optional data frame, providing the source for inputs x, y, and other glyph properties}
\item{radius}{values or field name of wedge radii}
\item{start_angle}{the angles to start the wedges, in radians, as measured from the horizontal}
\item{end_angle}{the angles to end the wedges, in radians, as measured from the horizontal}
\item{direction}{direction to turn between starting and ending angles ("anticlock", "clock")}
\item{color}{color for the glyph - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' - for glyphs with both fill and line properties, see "Handling color" below}
\item{alpha}{the alpha transparency of the glyph between 0 (transparent) and 1 (opaque) - if glyph has both fill and color properties, see "Handling alpha" below}
\item{hover}{a data frame of variables to be displayed when hovering over the glyph or a vector of variable names that can be found and extracted from the \code{data} argument}
\item{url}{a string of URLs or a single string that references a variable name (via @var_name) that can be found and extracted from the \code{data} argument}
\item{legend}{either a logical specifying not to plot a legend for this layer (FALSE) or a string indicating the name of the legend entry for this layer (note that when mapping plot attributes to variables in \code{data}, a legend is automatically created and does not need to be specified - see "Mapped plot attributes and legends" below)}
\item{lname}{layer name}
\item{lgroup}{layer group}
\item{\ldots}{additional parameters for fine control over fill and line properties (see "Additional parameters" below)}
}
\description{
Add a "wedge" layer to a Bokeh figure
}
\section{Handling color}{
The \code{color} parameter is a high-level plot attribute that provides default behavior for coloring glyphs.
\itemize{
\item When using a glyph that only has line properties, this will be the color of the line.
\item When using a glyph that has has line and fill properties, this will be the color of the line and the fill, with the alpha level of the fill reduced by 50\%.
\item If full control over fill and line color is desired, the \code{fill_color} and \code{line_color} attributes can be specified explicitly and will override \code{color}.
}
When color is \code{NULL} and \code{fill_color} or \code{line_color} are not specified, the color will be chosen from the theme.
}
\section{Handling alpha}{
The \code{alpha} is a high-level plot attribute that sets the transparency of the glyph being plotted.
\itemize{
\item When using a glyph that only has line properties, this will be the alpha of the line.
\item When using a glyph that has has line and fill properties, this will be the alpha of the line and the alpha of the fill will be set to 50\% of this value.
\item Individual fill and line alpha can be specified with \code{fill_alpha} and \code{line_alpha} and will override \code{alpha}.
}
}
\section{Mapped plot attributes and legends}{
When specifying an input data frame for a layer through the \code{data} argument, columns of \code{data} can be used to specify various plot attributes such as \code{color}, etc. For example, with \code{ly_points(..., data = iris, color = Species)}, the \code{Species} variable is used to determine how to color the points. Here, \code{Species} is "mapped" to the \code{color} attribute. Both continuous and categorical variables can be mapped. In the case of continuous variables, the range is cut into slices and attributes are applied to each interval. The mapping from the values of the variable to the actual plot attributes is determined based on the theme.
}
\section{Additional parameters}{
\tabular{ll}{
\code{fill_color} \tab color to use to fill the glyph with - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' \cr
\code{fill_alpha} \tab transparency value between 0 (transparent) and 1 (opaque) \cr
\code{line_color} \tab color to use to stroke lines with - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' \cr
\code{line_width} \tab stroke width in units of pixels \cr
\code{line_alpha} \tab transparency value between 0 (transparent) and 1 (opaque) \cr
\code{line_join} \tab how path segments should be joined together 'miter' 'round' 'bevel' \cr
\code{line_cap} \tab how path segments should be terminated 'butt' 'round' 'square' \cr
\code{line_dash} \tab array of integer pixel distances that describe the on-off pattern of dashing to use \cr
\code{line_dash_offset} \tab the distance in pixels into the line_dash that the pattern should start from
}
}
\examples{
\donttest{
rescale <- function(x)
(x - min(x)) / diff(range(x))
figure() \%>\%
ly_annular_wedge(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
inner_radius = 0.1, outer_radius = 0.15, alpha = 0.5,
hover = Species)
figure() \%>\%
ly_wedge(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
radius = 0.15, alpha = 0.5,
hover = Species)
figure() \%>\%
ly_arc(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
alpha = 0.5)
figure() \%>\%
ly_annulus(Sepal.Length, Sepal.Width, data = iris,
color = Species, hover = Species,
outer_radius = rescale(Petal.Length) * 0.3,
inner_radius = rescale(Petal.Length) * 0.1)
}
}
\seealso{
Other layer functions: \code{\link{ly_abline}};
\code{\link{ly_annular_wedge}}; \code{\link{ly_annulus}};
\code{\link{ly_arc}}; \code{\link{ly_bezier}};
\code{\link{ly_boxplot}}; \code{\link{ly_contour}};
\code{\link{ly_crect}}; \code{\link{ly_curve}};
\code{\link{ly_density}}; \code{\link{ly_hist}};
\code{\link{ly_image_url}}; \code{\link{ly_image}};
\code{\link{ly_lines}}; \code{\link{ly_map}};
\code{\link{ly_multi_line}}; \code{\link{ly_oval}};
\code{\link{ly_patch}}; \code{\link{ly_points}};
\code{\link{ly_polygons}}; \code{\link{ly_quadratic}};
\code{\link{ly_quantile}}; \code{\link{ly_ray}};
\code{\link{ly_rect}}; \code{\link{ly_segments}};
\code{\link{ly_text}}
}
| 6,780 | mit |
0579798a01351e1769bbe3ab1818444a1cbc3df4 | jrounds/rbokeh | man/ly_wedge.Rd | % Generated by roxygen2 (4.1.1): do not edit by hand
% Please edit documentation in R/layer_glyphs.R
\name{ly_wedge}
\alias{ly_wedge}
\title{Add a "wedge" layer to a Bokeh figure}
\usage{
ly_wedge(fig, x, y = NULL, data = NULL, radius = 0.3, start_angle = 0,
end_angle = 2 * pi, direction = "anticlock", color = NULL, alpha = 1,
hover = NULL, url = NULL, legend = NULL, lname = NULL,
lgroup = NULL, ...)
}
\arguments{
\item{fig}{figure to modify}
\item{x}{values or field name of center x coordinates}
\item{y}{values or field name of center y coordinates}
\item{data}{an optional data frame, providing the source for inputs x, y, and other glyph properties}
\item{radius}{values or field name of wedge radii}
\item{start_angle}{the angles to start the wedges, in radians, as measured from the horizontal}
\item{end_angle}{the angles to end the wedges, in radians, as measured from the horizontal}
\item{direction}{direction to turn between starting and ending angles ("anticlock", "clock")}
\item{color}{color for the glyph - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' - for glyphs with both fill and line properties, see "Handling color" below}
\item{alpha}{the alpha transparency of the glyph between 0 (transparent) and 1 (opaque) - if glyph has both fill and color properties, see "Handling alpha" below}
\item{hover}{a data frame of variables to be displayed when hovering over the glyph or a vector of variable names that can be found and extracted from the \code{data} argument}
\item{url}{a string of URLs or a single string that references a variable name (via @var_name) that can be found and extracted from the \code{data} argument}
\item{legend}{either a logical specifying not to plot a legend for this layer (FALSE) or a string indicating the name of the legend entry for this layer (note that when mapping plot attributes to variables in \code{data}, a legend is automatically created and does not need to be specified - see "Mapped plot attributes and legends" below)}
\item{lname}{layer name}
\item{lgroup}{layer group}
\item{\ldots}{additional parameters for fine control over fill and line properties (see "Additional parameters" below)}
}
\description{
Add a "wedge" layer to a Bokeh figure
}
\section{Handling color}{
The \code{color} parameter is a high-level plot attribute that provides default behavior for coloring glyphs.
\itemize{
\item When using a glyph that only has line properties, this will be the color of the line.
\item When using a glyph that has has line and fill properties, this will be the color of the line and the fill, with the alpha level of the fill reduced by 50\%.
\item If full control over fill and line color is desired, the \code{fill_color} and \code{line_color} attributes can be specified explicitly and will override \code{color}.
}
When color is \code{NULL} and \code{fill_color} or \code{line_color} are not specified, the color will be chosen from the theme.
}
\section{Handling alpha}{
The \code{alpha} is a high-level plot attribute that sets the transparency of the glyph being plotted.
\itemize{
\item When using a glyph that only has line properties, this will be the alpha of the line.
\item When using a glyph that has has line and fill properties, this will be the alpha of the line and the alpha of the fill will be set to 50\% of this value.
\item Individual fill and line alpha can be specified with \code{fill_alpha} and \code{line_alpha} and will override \code{alpha}.
}
}
\section{Mapped plot attributes and legends}{
When specifying an input data frame for a layer through the \code{data} argument, columns of \code{data} can be used to specify various plot attributes such as \code{color}, etc. For example, with \code{ly_points(..., data = iris, color = Species)}, the \code{Species} variable is used to determine how to color the points. Here, \code{Species} is "mapped" to the \code{color} attribute. Both continuous and categorical variables can be mapped. In the case of continuous variables, the range is cut into slices and attributes are applied to each interval. The mapping from the values of the variable to the actual plot attributes is determined based on the theme.
}
\section{Additional parameters}{
\tabular{ll}{
\code{fill_color} \tab color to use to fill the glyph with - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' \cr
\code{fill_alpha} \tab transparency value between 0 (transparent) and 1 (opaque) \cr
\code{line_color} \tab color to use to stroke lines with - a hex code (with no alpha) or any of the 147 named CSS colors, e.g 'green', 'indigo' \cr
\code{line_width} \tab stroke width in units of pixels \cr
\code{line_alpha} \tab transparency value between 0 (transparent) and 1 (opaque) \cr
\code{line_join} \tab how path segments should be joined together 'miter' 'round' 'bevel' \cr
\code{line_cap} \tab how path segments should be terminated 'butt' 'round' 'square' \cr
\code{line_dash} \tab array of integer pixel distances that describe the on-off pattern of dashing to use \cr
\code{line_dash_offset} \tab the distance in pixels into the line_dash that the pattern should start from
}
}
\examples{
\donttest{
rescale <- function(x)
(x - min(x)) / diff(range(x))
figure() \%>\%
ly_annular_wedge(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
inner_radius = 0.1, outer_radius = 0.15, alpha = 0.5,
hover = Species)
figure() \%>\%
ly_wedge(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
radius = 0.15, alpha = 0.5,
hover = Species)
figure() \%>\%
ly_arc(Sepal.Length, Sepal.Width, data = iris,
end_angle = rescale(Petal.Length)*2*pi, color = Species,
alpha = 0.5)
figure() \%>\%
ly_annulus(Sepal.Length, Sepal.Width, data = iris,
color = Species, hover = Species,
outer_radius = rescale(Petal.Length) * 0.3,
inner_radius = rescale(Petal.Length) * 0.1)
}
}
\seealso{
Other layer functions: \code{\link{ly_abline}};
\code{\link{ly_annular_wedge}}; \code{\link{ly_annulus}};
\code{\link{ly_arc}}; \code{\link{ly_bezier}};
\code{\link{ly_boxplot}}; \code{\link{ly_contour}};
\code{\link{ly_crect}}; \code{\link{ly_curve}};
\code{\link{ly_density}}; \code{\link{ly_hist}};
\code{\link{ly_image_url}}; \code{\link{ly_image}};
\code{\link{ly_lines}}; \code{\link{ly_map}};
\code{\link{ly_multi_line}}; \code{\link{ly_oval}};
\code{\link{ly_patch}}; \code{\link{ly_points}};
\code{\link{ly_polygons}}; \code{\link{ly_quadratic}};
\code{\link{ly_quantile}}; \code{\link{ly_ray}};
\code{\link{ly_rect}}; \code{\link{ly_segments}};
\code{\link{ly_text}}
}
| 6,780 | mit |
8cb146a0aabb021525286312e873254be67706ab | cran/favir | man/RBindPreLatex.Rd | \name{RBindPreLatex}
\alias{RBindPreLatex}
\title{Join several favir.prelatex objects into one}
\description{ When a favir data frame is printed, it is first converted
into an object of type favir.prelatex. This intermediate stage is
returned by the \code{PreLatexFDF} function. }
\usage{
RBindPreLatex(..., include.headings=TRUE)
}
\arguments{
\item{...}{Two or more favir.prelatex objects}
\item{include.headings}{Whether to keep the headings of the prelatex
objects (other than the first, which is always kept}
}
\details{\code{RBindPreLatex} may be useful for joining two tables
horizontally even when they don't hold comparable information.
}
\seealso{
\code{\link{PreLatexFDF}}.
}
\examples{
fdf1 <- FavirDF(data.frame(a=1:5, b=6:10))
pl.fdf1 <- PreLatexFDF(fdf1)
fdf2 <- FavirDF(data.frame(c=11:15, d=16:20))
pl.fdf2 <- PreLatexFDF(fdf2)
print(RBindPreLatex(pl.fdf1, pl.fdf2))
}
| 915 | gpl-2.0 |
7ff66fbb1be62bbe52c18670f638846db4450fcd | jasenfinch/mzAnnotation | man/filterACCESSIONS.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/allGenerics.R, R/filter-methods.R
\name{filterACCESSIONS}
\alias{filterACCESSIONS}
\alias{filterACCESSIONS,MetaboliteDatabase-method}
\title{Filter accessions}
\usage{
filterACCESSIONS(db, ids)
\S4method{filterACCESSIONS}{MetaboliteDatabase}(db, ids)
}
\arguments{
\item{db}{S4 object of class MetaboliteDatabase}
\item{ids}{vector of accession IDs}
}
\description{
Filter a MetaboliteDatabase based on given accession IDs.
}
\examples{
db <- metaboliteDB(aminoAcids,descriptors(aminoAcids$SMILES))
db <- filterACCESSIONS(db,c(1,2))
}
| 615 | gpl-3.0 |
7c94cf2051685f223204305a791508a5823fb8b2 | ad1729/akshat | man/variable_importance.randomForest.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/random_forest.R
\name{variable_importance.randomForest}
\alias{variable_importance.randomForest}
\title{Random Forest: Variable Importance Bar Chart}
\usage{
\method{variable_importance}{randomForest}(object, top_k = 10, v = FALSE,
show_plotly = FALSE)
}
\arguments{
\item{object}{Model object returned by the \code{randomForest()}}
\item{top_k}{Top K predictors to include in the horizontal bar chart
(defaults to 10 or all if p <= 10)}
\item{v}{Logical (defaults to FALSE) Should the bars be plotted vertically?}
\item{show_plotly}{Generate a plotly plot instead of a ggplot plot}
}
\description{
ggplot for the variable importance returned by \code{randomForest()} in
the randomForest package.
}
\details{
Calling \code{randomForest(..., importance = TRUE)}:
Regression: returns two importance measures "%IncMSE" and "IncNodePurity"
Classification: returns two importance measures "MeanDecreaseAccuracy" and
"MeanDecreaseGini"
Calling \code{randomForest(..., importance = FALSE)}:
Regression: returns one importance measure "IncNodePurity"
Classification: returns one importance measure "MeanDecreaseGini"
Importance measures are subsetted by matching "Mean" in colnames for classification
or "Inc" in colnames for regression
}
\examples{
## Classification
fit = randomForest::randomForest(Species ~ ., data = iris, importance = TRUE)
variable_importance(fit)
fit = randomForest::randomForest(Species ~ ., data = iris, importance = FALSE)
variable_importance(fit)
## Regression
fit1 = randomForest::randomForest(Petal.Length ~ ., data = iris, importance = TRUE)
variable_importance(fit1)
fit1 = randomForest::randomForest(Petal.Length ~ ., data = iris, importance = FALSE)
variable_importance(fit1)
}
| 1,795 | mit |
f2e9e2cb7765c482b1754a6b797da1970d180be4 | Ibasam/IBASAM | IBASAM/man/look_environment_data.Rd | \name{look_environment_data}
\alias{look_environment_data}
%- Also NEED an '\alias' for EACH other topic documented here.
\title{
look_environment_data
}
\description{
%% ~~ A concise (1-5 lines) description of what the function does. ~~
}
\usage{
look_environment_data()
}
%- maybe also 'usage' for other objects documented here.
\details{
%% ~~ If necessary, more details than the description above ~~
}
\value{
%% ~Describe the value returned
%% If it is a LIST, use
%% \item{comp1 }{Description of 'comp1'}
%% \item{comp2 }{Description of 'comp2'}
%% ...
}
\references{
%% ~put references to the literature/web site here ~
}
\author{
Cyril Piou
}
\note{
%% ~~further notes~~
}
%% ~Make other sections like Warning with \section{Warning }{....} ~
\seealso{
%% ~~objects to See Also as \code{\link{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 ()
{
nb_day <- recall_nb_day_simulations()
env <- .C("look_environment_data", as.integer(nb_day), as.double(1:nb_day),
as.double(1:nb_day), as.double(1:nb_day), PACKAGE = "libIbasam")
res <- data.frame(days = env[[2]], Temperature = env[[3]],
logFlow = env[[4]])
return(res)
}
}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
\keyword{ misc }
\keyword{ utilities }
\keyword{ programming }
| 1,553 | gpl-3.0 |
efdff89b6161a8aa58617d0061a391ed4e91b142 | davebraze/FDButils | man/sampleMode.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/sampleMode.R
\name{sampleMode}
\alias{sampleMode}
\title{Get the sample mode of a vector or matrix.}
\usage{
sampleMode(x, na.rm = FALSE)
}
\arguments{
\item{x}{A vector or matrix.}
\item{na.rm}{If TRUE, remove NAs from x, if FALSE (default) retain them.}
}
\value{
A single value corresponding to the most common value in x.
}
\description{
Return the most common value in a sample or, for numerix x with no duplicate
values, return the maximum density estimate.
}
\details{
Returns the mode (most common value) of a vector or matrix or, for numerix x with no
duplicate values, return the maximum density estimate. For non-numeric x with no duplicates
return NA. When there is more than 1 mode, return the one whose value occurs first in x.
}
\examples{
x0 <- sample(1:26, 5000, replace=TRUE)
sampleMode(x0)
x1 <- sample(letters, 5000, replace=TRUE)
sampleMode(x1)
x2 <- rnorm(100000, m=9.5)
sampleMode(x2)
}
\author{
David Braze \email{[email protected]}
}
| 1,054 | mit |
03c4d4e7951e3b12647fffb42d9c3d6aecd54de5 | zlskidmore/GenVisR | man/genCov_alignPlot.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/genCov_alignPlot.R
\name{genCov_alignPlot}
\alias{genCov_alignPlot}
\title{align plots on an axis}
\usage{
genCov_alignPlot(plot_list, axis = "both")
}
\arguments{
\item{plot_list}{list of ggplot objects}
\item{axis}{character string to specify the axis to align plotting space on,
one of both, width, height}
}
\value{
ggplotGrob object
}
\description{
given a list of plots, align them on plotting space
}
| 487 | cc0-1.0 |
e5f07b5d9f9e2444818165681c62c3ae21192674 | hkv-consultants/bowa | rbowa/bowa/man/teken_kaart.Rd | \name{teken.kaart}
\alias{teken.kaart}
\title{
Kaartweergave
}
\description{
Functie om specifieke kaarten (rasters) te plotten naar het scherm.
}
\usage{
teken.kaart(kaarten, selectie)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{kaarten}{list met kaartmateriaal, ingeladen met \code{\link{lees.kaarten}}.}
\item{selectie}{naam van de gewenste kaart (bijvoorbeeld "te").}
}
\details{
Met deze functie kun je een raster in de data frame \emph{kaarten} plotten. De functie heeft geen uitvoer.
}
\value{
%% ~Describe the value returned
%% If it is a LIST, use
%% \item{comp1 }{Description of 'comp1'}
%% \item{comp2 }{Description of 'comp2'}
%% ...
}
%\references{
%% ~put references to the literature/web site here ~
%}
\author{
Maarten-Jan Kallen, \email{[email protected]}
}
%\note{
%% ~~further notes~~
%}
%% ~Make other sections like Warning with \section{Warning }{....} ~
%\seealso{
%% ~~objects to See Also as \code{\link{help}}, ~~~
%}
%\examples{
%}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
%\keyword{ ~kwd1 }
%\keyword{ ~kwd2 }% __ONLY ONE__ keyword per line
| 1,211 | gpl-3.0 |
f832a5f825c4068dd82688a47cc159e1da08ff33 | julian-gehring/SomaticSignatures | man/SomaticSignatures-package.Rd | \name{SomaticSignatures}
\alias{SomaticSignatures}
\alias{SomaticSignatures-package}
\title{SomaticSignatures package}
\description{
Identifying somatic signatures of single nucleotide variants. This
package provides a infrastructure related to the methodology described
in Nik-Zainal (2012, Cell), with flexibility in the matrix
decomposition algorithms.
}
\details{
The 'SomaticSignatures' package offers the framework for identifying
mutational signatures of single nucleotide variants (SNVs) from
high-throughput experiments. In the concept of mutational signatures,
a base change resulting from an SNV is regarded in term of motifs
which embeds the variant in the context of the surrounding genomic
sequence. Based on the frequency of such motifs across samples,
mutational signatures and their occurrance in the samples can be
estimated. An introduction into the methodology and a use case are
illustrated in the vignette of this package.
}
\author{
Julian Gehring, Bernd Fischer, Michael Lawrence, Wolfgang Huber:
SomaticSignatures: Inferring Mutational Signatures from Single
Nucleotide Variants. 2015, bioRxiv preprint,
\url{http://dx.doi.org/10.1101/010686}
Maintainer: Julian Gehring, EMBL Heidelberg <[email protected]>
}
\references{
Nik-Zainal, Serena, Ludmil B. Alexandrov, David C. Wedge, Peter Van Loo,
Christopher D. Greenman, Keiran Raine, David Jones, et al. "Mutational
Processes Molding the Genomes of 21 Breast Cancers." Cell 149, no. 5
(May 25, 2012): 979-993. doi:10.1016/j.cell.2012.04.024.
Alexandrov, Ludmil B., Serena Nik-Zainal, David C. Wedge, Samuel
A. J. R. Aparicio, Sam Behjati, Andrew V. Biankin, Graham R. Bignell, et
al. "Signatures of Mutational Processes in Human Cancer." Nature 500,
no. 7463 (August 22, 2013): 415-421. doi:10.1038/nature12477.
Gaujoux, Renaud, and Cathal Seoighe. "A Flexible R Package for
Nonnegative Matrix Factorization." BMC Bioinformatics 11, no. 1 (July 2,
2010): 367. doi:10.1186/1471-2105-11-367.
Stacklies, Wolfram, Henning Redestig, Matthias Scholz, Dirk Walther, and
Joachim Selbig. "pcaMethods - A Bioconductor Package Providing PCA Methods
for Incomplete Data." Bioinformatics 23, no. 9 (May 1, 2007):
1164-1167. doi:10.1093/bioinformatics/btm069.
}
\examples{
vignette(package = "SomaticSignatures")
}
\keyword{package}
| 2,399 | mit |
03c4d4e7951e3b12647fffb42d9c3d6aecd54de5 | jkunisak/GenVisR | man/genCov_alignPlot.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/genCov_alignPlot.R
\name{genCov_alignPlot}
\alias{genCov_alignPlot}
\title{align plots on an axis}
\usage{
genCov_alignPlot(plot_list, axis = "both")
}
\arguments{
\item{plot_list}{list of ggplot objects}
\item{axis}{character string to specify the axis to align plotting space on,
one of both, width, height}
}
\value{
ggplotGrob object
}
\description{
given a list of plots, align them on plotting space
}
| 487 | cc0-1.0 |
d52f2b58ef8bf1d56ef07d2ea247a03febd545bc | TiphaineCMartin/coMET | man/read.config.Rd | \name{read.config}
\alias{read.config}
%- Also NEED an '\alias' for EACH other topic documented here.
\title{
Extract the values of variables from configuration file
}
\description{
Extract the values of variables from configuration file
}
\usage{
read.config(config.file, config.var)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{config.file}{
Configuration file
}
\item{config.var}{
list of all variables defined in configuration file or via options of
comet function
}
}
\value{
Return config.var updated with the different values of options found in the configuration file
}
\author{
Tiphaine Martin
}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
\keyword{ internal }
\keyword{ dplot }% __ONLY ONE__ keyword per line
| 801 | gpl-2.0 |
a4acfb322bdedde1ce886823e32540b5b74f0e4a | nimble-dev/nimble | packages/nimble/man/setSize.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/types_numericLists.R
\name{setSize}
\alias{setSize}
\title{set the size of a numeric variable in NIMBLE}
\usage{
setSize(numObj, ..., copy = TRUE, fillZeros = TRUE)
}
\arguments{
\item{numObj}{This is the object to be resized}
\item{...}{sizes, provided as scalars, in order, or as a single vector}
\item{copy}{logical indicating whether values should be preserved (in column-major order)}
\item{fillZeros}{logical indicating whether newly allocated space should be initialized with zeros (in compiled code)}
}
\description{
set the size of a numeric variable in NIMBLE. This works in R and NIMBLE, but in R it usually has no effect.
}
\details{
Note that assigning the result of \code{numeric}, \code{integer}, \code{logical}, \code{matrix}, or \code{array} is often as good or better than using \code{setSize}. For example, `x <- matrix(nrow = 5, ncol = 5)` is equivalent to `setSize(x, 5, 5)` but the former allows more control over initialization.
This function is part of the NIMBLE language. Its purpose is to explicitly resize a multivariate object (vector, matrix or array), currently up to 4 dimensions. Explicit resizing is not needed when an entire object is assigned to. For example, in \code{Y <- A \%*\% B}, where A and B are matrices, \code{Y} will be resized automatically. Explicit resizing is necessary when assignment will be by indexed elements or blocks, if the object is not already an appropriate size for the assignment. E.g. prior to \code{Y[5:10] <- A \%*\% B}, one can use setSize to ensure that \code{Y} has a size (length) of at least 10.
This does work in uncompiled (R) and well as compiled execution, but in some cases it is only necessary for compiled execution. During uncompiled execution, it may not catch bugs due to resizing because some R objects will be dynamically resized during assignments anyway.
If preserving values in the resized object and/or initializing new values with 0 is not necessary, then setting these arguments to FALSE will yield slightly more efficient compiled code.
}
\author{
NIMBLE development team
}
| 2,156 | bsd-3-clause |
03c4d4e7951e3b12647fffb42d9c3d6aecd54de5 | zskidmor/GenVisR | man/genCov_alignPlot.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/genCov_alignPlot.R
\name{genCov_alignPlot}
\alias{genCov_alignPlot}
\title{align plots on an axis}
\usage{
genCov_alignPlot(plot_list, axis = "both")
}
\arguments{
\item{plot_list}{list of ggplot objects}
\item{axis}{character string to specify the axis to align plotting space on,
one of both, width, height}
}
\value{
ggplotGrob object
}
\description{
given a list of plots, align them on plotting space
}
| 487 | cc0-1.0 |
03c4d4e7951e3b12647fffb42d9c3d6aecd54de5 | zskidmor/GGgenome | man/genCov_alignPlot.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/genCov_alignPlot.R
\name{genCov_alignPlot}
\alias{genCov_alignPlot}
\title{align plots on an axis}
\usage{
genCov_alignPlot(plot_list, axis = "both")
}
\arguments{
\item{plot_list}{list of ggplot objects}
\item{axis}{character string to specify the axis to align plotting space on,
one of both, width, height}
}
\value{
ggplotGrob object
}
\description{
given a list of plots, align them on plotting space
}
| 487 | cc0-1.0 |
06b47c13265b81ffdf99a941af37a454e17b70ea | vmikk/metagMisc | man/phyloseq_mult_raref_div.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/phyloseq_mult_raref_div.R
\name{phyloseq_mult_raref_div}
\alias{phyloseq_mult_raref_div}
\title{Average diversity estimates across multiple rarefaction iterations.}
\usage{
phyloseq_mult_raref_div(physeq, SampSize = min(sample_sums(physeq)),
iter = 1000, divindex = c("Observed", "Shannon"), parallel = FALSE,
verbose = TRUE, ...)
}
\arguments{
\item{physeq}{A phyloseq-class object}
\item{SampSize}{Rarefaction depth (number of reads to sample)}
\item{iter}{Number of rarefication iterations}
\item{divindex}{Alpha-diversity measures to estimate (for the supported indices see \code{\link[phyloseq]{estimate_richness}})}
\item{parallel}{Logical; if TRUE, attempts to run the function on multiple cores}
\item{verbose}{Logical; if TRUE, progress messages from the function will be printed}
\item{...}{Additional argument may be passed to \code{\link{phyloseq_mult_raref}}}
}
\value{
A data.frame of the richness estimates.
}
\description{
This function performs multiple rarefaction and estimates average diversity (e.g., Simpson or Shannon indices) for each sample.
}
| 1,157 | mit |
b87ddfbd7aafc5260dc29f4e43aae63266610992 | PoisonAlien/maftools | man/vafCompare.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/vafComapre.R
\name{vafCompare}
\alias{vafCompare}
\title{compare VAF across two cohorts}
\usage{
vafCompare(
m1,
m2,
genes = NULL,
top = 5,
vafCol1 = NULL,
vafCol2 = NULL,
m1Name = "M1",
m2Name = "M2",
cols = c("#2196F3", "#4CAF50"),
sigvals = TRUE,
nrows = NULL,
ncols = NULL
)
}
\arguments{
\item{m1}{first \code{\link{MAF}} object. Required.}
\item{m2}{second \code{\link{MAF}} object. Required.}
\item{genes}{specify genes for which plot has to be generated. Default NULL.}
\item{top}{if \code{genes} is NULL plots top n number of genes. Defaults to 5.}
\item{vafCol1}{manually specify column name for vafs in \code{m1}. Default looks for column 't_vaf'}
\item{vafCol2}{manually specify column name for vafs in \code{m2}. Default looks for column 't_vaf'}
\item{m1Name}{optional name for first cohort}
\item{m2Name}{optional name for second cohort}
\item{cols}{vector of colors corresponding to \code{m1} and \code{m2} respectivelly.}
\item{sigvals}{Estimate and add significance stars. Default TRUE.}
\item{nrows}{Number of rows in the layout. Default NULL - estimated automatically}
\item{ncols}{Number of genes drawn per row. Default 4}
}
\description{
Draw boxplot distibution of VAFs across two cohorts
}
| 1,327 | mit |
d0736619087bfe22f4da3cb5daaa64ef0fbf3331 | allr/r-instrumented | src/library/stats/man/supsmu.Rd | % File src/library/stats/man/supsmu.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2016 R Core Team
% Distributed under GPL 2 or later
\name{supsmu}
\alias{supsmu}
\title{Friedman's SuperSmoother}
\description{
Smooth the (x, y) values by Friedman's \sQuote{super smoother}.
}
\usage{
supsmu(x, y, wt =, span = "cv", periodic = FALSE, bass = 0, trace = FALSE)
}
\arguments{
\item{x}{x values for smoothing}
\item{y}{y values for smoothing}
\item{wt}{case weights, by default all equal}
\item{span}{the fraction of the observations in the span of the running
lines smoother, or \code{"cv"} to choose this by leave-one-out
cross-validation.}
\item{periodic}{if \code{TRUE}, the x values are assumed to be in
\code{[0, 1]} and of period 1.}
\item{bass}{controls the smoothness of the fitted curve. Values of up
to 10 indicate increasing smoothness.}
\item{trace}{logical, if true, prints one line of info \dQuote{per
spar}, notably useful for \code{"cv"}.}
}
\details{
\code{supsmu} is a running lines smoother which chooses between three
spans for the lines. The running lines smoothers are symmetric, with
\code{k/2} data points each side of the predicted point, and values of
\code{k} as \code{0.5 * n}, \code{0.2 * n} and \code{0.05 * n}, where
\code{n} is the number of data points. If \code{span} is specified,
a single smoother with span \code{span * n} is used.
The best of the three smoothers is chosen by cross-validation for each
prediction. The best spans are then smoothed by a running lines
smoother and the final prediction chosen by linear interpolation.
The FORTRAN code says: \dQuote{For small samples (\code{n < 40}) or if
there are substantial serial correlations between observations close
in x-value, then a pre-specified fixed span smoother (\code{span >
0}) should be used. Reasonable span values are 0.2 to 0.4.}
Cases with non-finite values of \code{x}, \code{y} or \code{wt} are
dropped, with a warning.
}
\value{
A list with components
\item{x}{the input values in increasing order with duplicates removed.}
\item{y}{the corresponding y values on the fitted curve.}
}
\references{
Friedman, J. H. (1984)
SMART User's Guide.
Laboratory for Computational Statistics, Stanford University Technical
Report No.\sspace{}1.
Friedman, J. H. (1984)
A variable span scatterplot smoother.
Laboratory for Computational Statistics, Stanford University Technical
Report No.\sspace{}5.
}
\seealso{\code{\link{ppr}}}
\examples{
require(graphics)
with(cars, {
plot(speed, dist)
lines(supsmu(speed, dist))
lines(supsmu(speed, dist, bass = 7), lty = 2)
})
}
\keyword{smooth}
| 2,730 | gpl-2.0 |
77db28ee2cad829ba2d1b95d11004b7f4abbf635 | andyshinn/dx-toolkit | src/R/dxR/man/workflowSetDetails.Rd | \name{workflowSetDetails}
\alias{workflowSetDetails}
\title{workflowSetDetails API wrapper}
\usage{
workflowSetDetails(objectID,
inputParams = emptyNamedList, jsonifyData = TRUE,
alwaysRetry = TRUE)
}
\arguments{
\item{objectID}{DNAnexus object ID}
\item{inputParams}{Either an R object that will be
converted into JSON using \code{RJSONIO::toJSON} to be
used as the input to the API call. If providing the JSON
string directly, you must set \code{jsonifyData} to
\code{FALSE}.}
\item{jsonifyData}{Whether to call \code{RJSONIO::toJSON}
on \code{inputParams} to create the JSON string or pass
through the value of \code{inputParams} directly.
(Default is \code{TRUE}.)}
\item{alwaysRetry}{Whether to always retry even when no
response is received from the API server}
}
\value{
If the API call is successful, the parsed JSON of the API
server response is returned (using
\code{RJSONIO::fromJSON}).
}
\description{
This function makes an API call to the
\code{/workflow-xxxx/setDetails} API method; it is a
simple wrapper around the \code{\link{dxHTTPRequest}}
function which makes POST HTTP requests to the API
server.
}
\references{
API spec documentation:
\url{https://wiki.dnanexus.com/API-Specification-v1.0.0/Details-and-Links#API-method\%3A-\%2Fclass-xxxx\%2FsetDetails}
}
\seealso{
\code{\link{dxHTTPRequest}}
}
| 1,380 | apache-2.0 |