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 |
|---|---|---|---|---|---|
c8fe1f04b3697bdca7291efb870759018021dcf4 | ChiWang/r-source | src/library/utils/man/make.socket.Rd | % File src/library/utils/man/make.socket.Rd
% Part of the R package, http://www.R-project.org
% Copyright 1995-2015 R Core Team
% Distributed under GPL 2 or later
\name{make.socket}
\alias{make.socket}
\alias{print.socket}
\title{Create a Socket Connection}
\usage{
make.socket(host = "localhost", port, fail = TRUE, server = FALSE)
}
\arguments{
\item{host}{name of remote host}
\item{port}{port to connect to/listen on}
\item{fail}{failure to connect is an error?}
\item{server}{a server socket?}
}
\description{
With \code{server = FALSE} attempts to open a client socket to the
specified port and host. With \code{server = TRUE} the \R process
listens on the specified port for a connection and then returns a
server socket. It is a good idea to use \code{\link{on.exit}} to
ensure that a socket is closed, as you only get 64 of them.
}
\value{
An object of class \code{"socket"}, a list with components:
\item{socket}{socket number. This is for internal use. On a
Unix-alike it is a file descriptor.}
\item{port}{port number of the connection.}
\item{host}{name of remote computer.}
}
\author{Thomas Lumley}
\references{
Adapted from Luke Tierney's code for \code{XLISP-Stat}, in turn
based on code from Robbins and Robbins \dQuote{Practical UNIX Programming}.
}
\section{Warning}{
I don't know if the connecting host name returned
when \code{server = TRUE} can be trusted. I suspect not.
}
\seealso{
\code{\link{close.socket}}, \code{\link{read.socket}}.
Compiling in support for sockets is optional: see
\code{\link{capabilities}("sockets")} to see if it is available.
}
\examples{
daytime <- function(host = "localhost"){
a <- make.socket(host, 13)
on.exit(close.socket(a))
read.socket(a)
}
## Official time (UTC) from US Naval Observatory
\dontrun{daytime("tick.usno.navy.mil")}
}
\keyword{misc}
| 1,870 | gpl-2.0 |
2b5668807d096ec1adfb50ea59f692d09034c593 | nutterb/junkyard | man/test_auc_1curve.Rd | % Generated by roxygen2 (4.0.2): do not edit by hand
\name{test_auc_1curve}
\alias{test_auc_1curve}
\title{Power Analsis for Full Area Under the ROC Curve}
\usage{
test_auc_1curve(auc0 = NULL, auc1 = NULL, n = NULL, power = NULL,
alpha = 0.05, weights = list(c(1, 1)), one_tail = FALSE,
ordinal = FALSE)
}
\arguments{
\item{auc0}{The hypothesize (null) value of AUC.}
\item{auc1}{The observed or desired AUC.}
\item{n}{The total sample size}
\item{power}{The power of the test}
\item{alpha}{The significance level of the test.}
\item{weights}{Weighting of subjects with the condition
and those without. A vector \code{1, 3} indicates there
is one subject with the condition for every three
subjects without it. Defaults to equal sizes. The
weights are normalized, so they do not have to sum to
one.}
\item{one_tail}{Logical. Indicates if the test should be
a one tailed test.}
\item{ordinal}{Logical. Indicates if the independent
variable in the study is ordinal. This is currently
ignored.}
}
\description{
Calculates the power, sample size, or other parameters for
studies using Area Under the Curve (AUC) as the endpoint of
an anlysis using a single continuous or ordinal predictor.
}
\details{
The Hanley and McNeil estimator is used for continuous
predictors. Obuchowski's estimator for discrete ratings is
used for ordinal predictors.
}
\examples{
#* First example from \\url{http://www.bio.ri.ccf.org/doc/rocpower_help.txt}
#* but solving for n
test_auc_1curve(auc0 = .75, auc1 = .92,
n = NULL, alpha=.02,
power=.893, weights = list(c(35, 50)))
#* First example from \\url{http://www.bio.ri.ccf.org/doc/rocpower_help.txt}
test_auc_1curve(auc0 = .75, auc1 = .92,
n = 85, alpha=.02,
power=NULL,
weights = list(c(35, 50)))
}
\author{
Benjamin Nutter
}
\references{
Nancy A Obuchowski, "Sample size calculations in studies of
test accuracy," \emph{Statistical Methods in Medical
Research} 1998; 7: 371-392
James A. Hanley and Barbara J. McNeil, "The Meaning and Use
of the Area under a Receiver Operating Characteristic (ROC)
Curve," \emph{Radiology}. Vol 143. No 1, Pages 29-36, April
1982.
The bulk of this code is compared against C Zepp's SAS
Macro ROCPOWER. See reference 25 in the Obuchowski paper
above.
\url{http://www.bio.ri.ccf.org/doc/rocpower_help.txt}
\url{http://www.bio.ri.ccf.org/doc/rocpower.sas}
}
| 2,450 | gpl-2.0 |
ad1d2770c60f4233e63f442262fc0601bee819f0 | FvD/Nvim-R | R/nvimcom/man/nvim.plot.Rd | \name{nvim.plot}
\alias{nvim.plot}
\title{Plot an object}
\description{
Plot an object. If the object is numeric, plot histogram and boxplot instead
of default scatter plot.
}
\usage{
nvim.plot(x)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{x}{The object.}
}
| 298 | gpl-2.0 |
ad1d2770c60f4233e63f442262fc0601bee819f0 | jalvesaq/nvimcom | man/nvim.plot.Rd | \name{nvim.plot}
\alias{nvim.plot}
\title{Plot an object}
\description{
Plot an object. If the object is numeric, plot histogram and boxplot instead
of default scatter plot.
}
\usage{
nvim.plot(x)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{x}{The object.}
}
| 298 | gpl-2.0 |
ad1d2770c60f4233e63f442262fc0601bee819f0 | xdega/.dotfiles | .vim/.vim/R/nvimcom/man/nvim.plot.Rd | \name{nvim.plot}
\alias{nvim.plot}
\title{Plot an object}
\description{
Plot an object. If the object is numeric, plot histogram and boxplot instead
of default scatter plot.
}
\usage{
nvim.plot(x)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{x}{The object.}
}
| 298 | mit |
cbbc257e3991ffc1e9d203f9957ddba0d94b746e | mtna/rds-r | man/rds.dataset-class.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/classes.R
\docType{class}
\name{rds.dataset-class}
\alias{rds.dataset-class}
\title{Rich Data Services Data Set}
\description{
A data set contains the three main sections of an RDS query, metadata, data, and info. The metadata may or may not be present depending on what was requested in the query. If it is it will contain variable and classification metadata if available. The data will contain the actual data values that are returned from the query. The info will contain information about the query ran including the any limits, whether or not more columns or rows are available, and a total row count if available.
}
\section{Slots}{
\describe{
\item{\code{variables}}{A data frame of the variable information of the variables included in the query}
\item{\code{records}}{A data frame of the records returned.}
\item{\code{totals}}{A data frame of the totals returned (tabulation only).}
\item{\code{info}}{A data frame of the query information.}
}}
| 1,039 | apache-2.0 |
ad1d2770c60f4233e63f442262fc0601bee819f0 | jalvesaq/Nvim-R | R/nvimcom/man/nvim.plot.Rd | \name{nvim.plot}
\alias{nvim.plot}
\title{Plot an object}
\description{
Plot an object. If the object is numeric, plot histogram and boxplot instead
of default scatter plot.
}
\usage{
nvim.plot(x)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{x}{The object.}
}
| 298 | gpl-2.0 |
ad1d2770c60f4233e63f442262fc0601bee819f0 | mdlerch/nvimcom | man/nvim.plot.Rd | \name{nvim.plot}
\alias{nvim.plot}
\title{Plot an object}
\description{
Plot an object. If the object is numeric, plot histogram and boxplot instead
of default scatter plot.
}
\usage{
nvim.plot(x)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{x}{The object.}
}
| 298 | gpl-2.0 |
82c664da0b60d583e2278bb655dd6474aa7a224a | gregorbj/VisionEval | sources/modules/VEHouseholdVehicles/man/AssignVehicleOwnership.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/AssignVehicleOwnership.R
\name{AssignVehicleOwnership}
\alias{AssignVehicleOwnership}
\title{Calculate the number of vehicles owned by the household.}
\usage{
AssignVehicleOwnership(L)
}
\arguments{
\item{L}{A list containing the components listed in the Get specifications
for the module.}
}
\value{
A list containing the components specified in the Set
specifications for the module.
}
\description{
\code{AssignVehicleOwnership} calculate the number of vehicles owned by each
household.
}
\details{
This function calculates the number of vehicles owned by each household
given the characteristic of the household and the area where it resides.
}
| 727 | apache-2.0 |
db23dc18db17bd4afd51514eb4f0ae1d3dcf4477 | jcfisher/latentnetDiffusion | man/makeConstructMatrix.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/make_construct_matrix.R
\name{makeConstructMatrix}
\alias{makeConstructMatrix}
\title{Row-normalizes a matrix with arbitrary weighting for the diagonal}
\usage{
makeConstructMatrix(net, a)
}
\arguments{
\item{net:}{a statnet network object or a square matrix}
\item{a:}{a numeric value indicating how much weight to give to self vs.
other. 1 indicates full self-weight (diagonal), 0 indicates full other-
weight (off diagonal). Can be a vector to give each person different
weights.}
}
\value{
a square matrix whose rows sum to 1 or 0
}
\description{
Row-normalizes a matrix with arbitrary weighting for the diagonal
}
\note{
Calculates the construct matrix from Friedkin and Johnson (2011:40).
That matrix is defined as \eqn{AC + I - A}, where:
\deqn{C_{ij} = \frac{W_{ij}}{\sum_{k: i \ne k} W_{ik}}}
\eqn{C_{ii} = 0}, \eqn{A_{ii} = a_i}, and \eqn{A_{ij} = 0} for all
\eqn{i \ne j}.
Among indegree isolates, \eqn{\sum_{k: i \ne k} W_{ik} = 0}. In those cases,
\eqn{C_{ij} \coloneqq 0}, and \eqn{a_{i} \coloneqq 1}.
}
\references{
Friedkin, Noah E. and Eugene c. Johnson. 2011.
\emph{Social Influence Network Theory: A Sociological Examination of Small
Group Dynamics}. Cambridge University Press: New York.
}
| 1,331 | gpl-3.0 |
82c664da0b60d583e2278bb655dd6474aa7a224a | cities-lab/VisionEval | sources/modules/VEVehicleOwnership/man/AssignVehicleOwnership.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/AssignVehicleOwnership.R
\name{AssignVehicleOwnership}
\alias{AssignVehicleOwnership}
\title{Calculate the number of vehicles owned by the household.}
\usage{
AssignVehicleOwnership(L)
}
\arguments{
\item{L}{A list containing the components listed in the Get specifications
for the module.}
}
\value{
A list containing the components specified in the Set
specifications for the module.
}
\description{
\code{AssignVehicleOwnership} calculate the number of vehicles owned by each
household.
}
\details{
This function calculates the number of vehicles owned by each household
given the characteristic of the household and the area where it resides.
}
| 727 | apache-2.0 |
700759bfcf9daeaf00014f0bf52cbb145b6348f0 | Oshlack/splatter | man/zinbSimulate.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/zinb-simulate.R
\name{zinbSimulate}
\alias{zinbSimulate}
\title{ZINB-WaVE simulation}
\usage{
zinbSimulate(params = newZINBParams(), sparsify = TRUE, verbose = TRUE, ...)
}
\arguments{
\item{params}{ZINBParams object containing simulation parameters.}
\item{sparsify}{logical. Whether to automatically convert assays to sparse
matrices if there will be a size reduction.}
\item{verbose}{logical. Whether to print progress messages}
\item{...}{any additional parameter settings to override what is provided in
\code{params}.}
}
\value{
SingleCellExperiment containing simulated counts
}
\description{
Simulate counts using the ZINB-WaVE method.
}
\details{
This function is just a wrapper around \code{\link[zinbwave]{zinbSim}} that
takes a \code{\link{ZINBParams}}, runs the simulation then converts the
output to a \code{\link[SingleCellExperiment]{SingleCellExperiment}} object.
See \code{\link[zinbwave]{zinbSim}} and the ZINB-WaVE paper for
more details about how the simulation works.
}
\examples{
if (requireNamespace("zinbwave", quietly = TRUE)) {
sim <- zinbSimulate()
}
}
\references{
Campbell K, Yau C. Uncovering genomic trajectories with heterogeneous genetic
and environmental backgrounds across single-cells and populations. bioRxiv
(2017).
Risso D, Perraudeau F, Gribkova S, Dudoit S, Vert J-P. ZINB-WaVE: A general
and flexible method for signal extraction from single-cell RNA-seq data
bioRxiv (2017).
Paper: \url{10.1101/125112}
Code: \url{https://github.com/drisso/zinbwave}
}
| 1,585 | gpl-3.0 |
feecc2305e6c8bab28a38ac1ffe395a2fbbf21ff | WillemPaling/RDoubleClick | man/reports.run.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/reports.run.R
\name{reports.run}
\alias{reports.run}
\title{Run previously defined report from DoubleClick Reporting API}
\usage{
reports.run(profileId, reportId)
}
\arguments{
\item{profileId}{The ID of the profile associated with the report}
\item{reportId}{The ID of the report}
}
\value{
data table containing report data
}
\description{
reports.run
}
\details{
Run previously defined report from DoubleClick Reporting API
}
\examples{
\dontrun{
reports.run(1234567,8765431)
}
}
| 564 | mit |
7f972af5b239d32dda0a8ae6246cdd66252c7e88 | bvnlab/SCATTome | man/FeatureSelectionLasso.Rd | \name{FeatureSelectionLasso}
\alias{FeatureSelectionLasso}
%- Also NEED an '\alias' for EACH other topic documented here.
\title{
LASSO feature selection.
}
\description{
Feature selection using only LASSO.
}
\usage{
FeatureSelectionLasso(d)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{d}{
%% ~~Describe \code{d} 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{
%% ~~who you are~~
}
\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 (d)
{
library(glmnet)
y <- d$Status
x <- as.matrix(d[, -c(1, dim(d)[2])])
l <- cv.glmnet(x, y, nfolds = 10, family = "binomial")
lambdam <- l$lambda[which(l$cvm == min(l$cvm))]
m <- glmnet(x, y, family = "binomial", lambda = lambdam)
m1 <- glmnet(x, y, family = "binomial")
pdf("LASSO_Plots.pdf")
plot(l)
plot(m1)
dev.off()
c <- rownames(m$beta)[which(!(m$beta == 0))]
return(c)
}
}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
\keyword{ ~kwd1 }
\keyword{ ~kwd2 }% __ONLY ONE__ keyword per line
| 1,661 | gpl-3.0 |
68ca1ea9f30aac8b1267b8bcd2a8a1eb86ed1dd4 | c97sr/idd | man/extract_predicted_points_seir.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/forecasting_practical.R
\name{extract_predicted_points_seir}
\alias{extract_predicted_points_seir}
\title{extract predicted points for SEIR model}
\usage{
extract_predicted_points_seir(
R_0,
incidence_data,
current_week,
starting_week,
weeks_ahead
)
}
\arguments{
\item{R_0}{numeric vector of length 1: basic reproduction number}
\item{incidence_data}{data frame extracted by \code{extract_incidence}}
\item{current_week}{numeric vector of length 1: week number of the current week}
\item{starting_week}{numeric vector of length 1:
guess for week number when the epidemic started. Use data from starting week
to current week to predict}
\item{weeks_ahead}{numeric vector of length 1: number of weeks to predict ahead}
}
\value{
data frame with predicted points and original data
}
\description{
\code{extract_predicted_points_seir} takes the R_0
returned by \code{fit_seir} and extracts model predictions
}
| 1,034 | gpl-3.0 |
013f85ef4f09c5dba6dcf2ef6284d4b1efcf17ac | ebird/auk | man/auk_ebd.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/auk-ebd.r
\name{auk_ebd}
\alias{auk_ebd}
\title{Reference to EBD file}
\usage{
auk_ebd(file, file_sampling, sep = "\\t")
}
\arguments{
\item{file}{character; input file.}
\item{file_sampling}{character; optional input sampling event data file,
required if you intend to zero-fill the data to produce a presence-absence
data set. The sampling file consists of just effort information for every
eBird checklist. Any species not appearing in the EBD for a given checklist
is implicitly considered to have a count of 0. This file should be
downloaded at the same time as the EBD to ensure they are in sync.}
\item{sep}{character; the input field separator, the EBD is tab separated so
this should generally not be modified. Must only be a single character and
space delimited is not allowed since spaces appear in many of the fields.}
}
\value{
An \code{auk_ebd} object storing the file reference and the desired
filters once created with other package functions.
}
\description{
Create a reference to an eBird Basic Dataset (EBD) file in preparation for
filtering using AWK.
}
\details{
The EBD can be downloaded as a tab-separated text file from the
\href{http://ebird.org/ebird/data/download}{eBird website} after submitting a
request for access. As of February 2017, this file is nearly 150 GB making
it challenging to work with. If you're only interested in a single species
or a small region it is possible to submit a custom download request. This
approach is suggested to speed up processing time.
There are two potential pathways for preparing eBird data. Users wishing to
produce presence only data, should download the \href{http://ebird.org/ebird/data/download/}{eBird Basic Dataset}
and reference this file when calling \code{auk_ebd()}. Users wishing to produce
zero-filled, presence absence data should additionally download the sampling
event data file associated with the EBD. This file contains only checklist
information and can be used to infer absences. The sampling event data file
should be provided to \code{auk_ebd()} via the \code{file_sampling} argument. For
further details consult the vignettes.
}
\examples{
# set up reference to sample EBD file
f <- system.file("extdata/ebd-sample.txt", package = "auk")
auk_ebd(f)
# to produce zero-filled data, provide a sampling event data file
f_ebd <- system.file("extdata/zerofill-ex_ebd.txt", package = "auk")
f_smpl <- system.file("extdata/zerofill-ex_sampling.txt", package = "auk")
auk_ebd(f_ebd, file_sampling = f_smpl)
}
| 2,575 | gpl-3.0 |
18811faca567b57aae1b95bfd9fdbb0cdc757daf | rstudio/EDAWR | man/artists.Rd | % Generated by roxygen2 (4.1.0): do not edit by hand
% Please edit documentation in R/data.R
\docType{data}
\name{artists}
\alias{artists}
\title{Names of musicians}
\format{\preformatted{'data.frame': 4 obs. of 2 variables:
$ name : chr "George" "John" "Paul" "Ringo"
$ plays: chr "sitar" "guitar" "bass" "drums"
}}
\usage{
artists
}
\description{
A simple data set of musicians and the instruments they played.
}
\keyword{datasets}
| 440 | cc0-1.0 |
1dc7ef7d0392332e1ea1b62f5fafe9782efcabad | vertesy/RoxygenReady | RoxygenReady/man/rr_extract_all_descriptions_from_comment_annot.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/RoxygenReady.R
\name{rr_extract_all_descriptions_from_comment_annot}
\alias{rr_extract_all_descriptions_from_comment_annot}
\title{rr_extract_all_descriptions_from_comment_annot}
\usage{
rr_extract_all_descriptions_from_comment_annot(inFile)
}
\arguments{
\item{inFile}{input file with function definitions to be scanned}
}
\description{
Scan a script for (descriptive) comments in the 3d line of each function's Roxygen skeleton.
}
\examples{
rr_extract_all_descriptions_from_comment_annot (inFile = )
}
| 585 | gpl-3.0 |
3751eafe7c71cd4e9b1c5923d20fda143f8e03e8 | eddelbuettel/nanotime | man/nanoduration.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/nanoduration.R
\docType{class}
\name{nanoduration-class}
\alias{nanoduration-class}
\alias{nanoduration}
\alias{*,ANY,nanoduration-method}
\alias{*,nanoduration,ANY-method}
\alias{*,nanoduration,nanoduration-method}
\alias{+,ANY,nanoduration-method}
\alias{/,ANY,nanoduration-method}
\alias{/,nanoduration,ANY-method}
\alias{Complex,nanoduration-method}
\alias{Logic,ANY,nanoduration-method}
\alias{Logic,nanoduration,ANY-method}
\alias{Logic,nanoduration,nanoduration-method}
\alias{Math2,nanoduration-method}
\alias{Math,nanoduration-method}
\alias{Summary,nanoduration-method}
\alias{as.nanoduration,character-method}
\alias{as.nanoduration}
\alias{as.nanoduration,integer64-method}
\alias{as.nanoduration,numeric-method}
\alias{as.nanoduration,integer-method}
\alias{as.nanoduration,difftime-method}
\alias{as.nanoduration,NULL-method}
\alias{as.nanoduration,missing-method}
\alias{show,nanoduration-method}
\alias{print,nanoduration-method}
\alias{format.nanoduration}
\alias{as.integer64.nanoduration}
\alias{as.character,nanoduration-method}
\alias{is.na,nanoduration-method}
\alias{-,nanoduration,nanoduration-method}
\alias{-,nanoduration,integer64-method}
\alias{-,nanoduration,integer-method}
\alias{-,nanoduration,numeric-method}
\alias{-,nanoduration,difftime-method}
\alias{-,nanoduration,ANY-method}
\alias{-,nanotime,nanoduration-method}
\alias{-,nanotime,difftime-method}
\alias{-,integer64,nanoduration-method}
\alias{-,integer,nanoduration-method}
\alias{-,numeric,nanoduration-method}
\alias{-,difftime,nanoduration-method}
\alias{-,ANY,nanoduration-method}
\alias{+,nanoduration,ANY-method}
\alias{+,nanoduration,nanoduration-method}
\alias{+,nanoduration,integer64-method}
\alias{+,nanoduration,numeric-method}
\alias{+,nanoduration,difftime-method}
\alias{+,nanotime,nanoduration-method}
\alias{+,nanotime,difftime-method}
\alias{+,nanoduration,nanotime-method}
\alias{+,difftime,nanotime-method}
\alias{+,nanoival,nanoduration-method}
\alias{-,nanoival,nanoduration-method}
\alias{+,nanoduration,nanoival-method}
\alias{+,nanoival,difftime-method}
\alias{-,nanoival,difftime-method}
\alias{+,difftime,nanoival-method}
\alias{+,integer64,nanoduration-method}
\alias{+,numeric,nanoduration-method}
\alias{+,difftime,nanoduration-method}
\alias{*,nanoduration,numeric-method}
\alias{*,nanoduration,integer64-method}
\alias{*,numeric,nanoduration-method}
\alias{*,integer64,nanoduration-method}
\alias{/,nanoduration,nanoduration-method}
\alias{/,nanoduration,integer64-method}
\alias{/,nanoduration,numeric-method}
\alias{Arith,nanoduration,ANY-method}
\alias{Compare,nanoduration,character-method}
\alias{Compare,character,nanoduration-method}
\alias{Compare,nanoduration,ANY-method}
\alias{abs,nanoduration-method}
\alias{sign,nanoduration-method}
\alias{sum,nanoduration-method}
\alias{min,nanoduration-method}
\alias{max,nanoduration-method}
\alias{range,nanoduration-method}
\alias{[[,nanoduration-method}
\alias{[,nanoduration,numeric-method}
\alias{[,nanoduration,logical-method}
\alias{[,nanoduration,character-method}
\alias{[,nanoduration,ANY-method}
\alias{[<-,nanoduration,ANY,ANY,ANY-method}
\alias{c.nanoduration}
\alias{NA_nanoduration_}
\title{Duration type with nanosecond precision}
\format{
An object of class \code{nanoduration} of length 1.
}
\usage{
nanoduration(hours = 0L, minutes = 0L, seconds = 0L, nanoseconds = 0L)
\S4method{as.nanoduration}{character}(x)
\S4method{as.nanoduration}{integer64}(x)
\S4method{as.nanoduration}{numeric}(x)
\S4method{as.nanoduration}{integer}(x)
\S4method{as.nanoduration}{difftime}(x)
\S4method{as.nanoduration}{`NULL`}(x)
\S4method{as.nanoduration}{missing}(x)
\S4method{show}{nanoduration}(object)
\S4method{print}{nanoduration}(x, quote = FALSE, ...)
\method{format}{nanoduration}(x, ...)
\method{as.integer64}{nanoduration}(x, ...)
\S4method{as.character}{nanoduration}(x)
\S4method{is.na}{nanoduration}(x)
\S4method{-}{nanoduration,nanoduration}(e1, e2)
\S4method{-}{nanoduration,integer64}(e1, e2)
\S4method{-}{nanoduration,integer}(e1, e2)
\S4method{-}{nanoduration,numeric}(e1, e2)
\S4method{-}{nanoduration,difftime}(e1, e2)
\S4method{-}{nanoduration,ANY}(e1, e2)
\S4method{-}{nanotime,nanoduration}(e1, e2)
\S4method{-}{nanotime,difftime}(e1, e2)
\S4method{-}{integer64,nanoduration}(e1, e2)
\S4method{-}{integer,nanoduration}(e1, e2)
\S4method{-}{numeric,nanoduration}(e1, e2)
\S4method{-}{difftime,nanoduration}(e1, e2)
\S4method{-}{ANY,nanoduration}(e1, e2)
\S4method{+}{nanoduration,ANY}(e1, e2)
\S4method{+}{nanoduration,nanoduration}(e1, e2)
\S4method{+}{nanoduration,integer64}(e1, e2)
\S4method{+}{nanoduration,numeric}(e1, e2)
\S4method{+}{nanoduration,difftime}(e1, e2)
\S4method{+}{nanotime,nanoduration}(e1, e2)
\S4method{+}{nanotime,difftime}(e1, e2)
\S4method{+}{nanoduration,nanotime}(e1, e2)
\S4method{+}{difftime,nanotime}(e1, e2)
\S4method{+}{nanoival,nanoduration}(e1, e2)
\S4method{-}{nanoival,nanoduration}(e1, e2)
\S4method{+}{nanoduration,nanoival}(e1, e2)
\S4method{+}{nanoival,difftime}(e1, e2)
\S4method{-}{nanoival,difftime}(e1, e2)
\S4method{+}{difftime,nanoival}(e1, e2)
\S4method{+}{integer64,nanoduration}(e1, e2)
\S4method{+}{numeric,nanoduration}(e1, e2)
\S4method{+}{difftime,nanoduration}(e1, e2)
\S4method{*}{nanoduration,numeric}(e1, e2)
\S4method{*}{nanoduration,integer64}(e1, e2)
\S4method{*}{numeric,nanoduration}(e1, e2)
\S4method{*}{integer64,nanoduration}(e1, e2)
\S4method{/}{nanoduration,nanoduration}(e1, e2)
\S4method{/}{nanoduration,integer64}(e1, e2)
\S4method{/}{nanoduration,numeric}(e1, e2)
\S4method{Arith}{nanoduration,ANY}(e1, e2)
\S4method{Compare}{nanoduration,character}(e1, e2)
\S4method{Compare}{character,nanoduration}(e1, e2)
\S4method{Compare}{nanoduration,ANY}(e1, e2)
\S4method{abs}{nanoduration}(x)
\S4method{sign}{nanoduration}(x)
\S4method{sum}{nanoduration}(x, ..., na.rm = FALSE)
\S4method{min}{nanoduration}(x, ..., na.rm = FALSE)
\S4method{max}{nanoduration}(x, ..., na.rm = FALSE)
\S4method{range}{nanoduration}(x, ..., na.rm = FALSE)
\S4method{[[}{nanoduration}(x, i, j, ..., drop = FALSE)
\S4method{[}{nanoduration,numeric}(x, i, j, ..., drop = FALSE)
\S4method{[}{nanoduration,logical}(x, i, j, ..., drop = FALSE)
\S4method{[}{nanoduration,character}(x, i, j, ..., drop = FALSE)
\S4method{[}{nanoduration,ANY}(x, i, j, ..., drop = FALSE)
\S4method{[}{nanoduration,ANY,ANY,ANY}(x, i, j, ...) <- value
\method{c}{nanoduration}(...)
NA_nanoduration_
}
\arguments{
\item{hours}{number of hours}
\item{minutes}{number of minutes}
\item{seconds}{number of seconds}
\item{nanoseconds}{number of nanoseconds}
\item{x}{a \code{nanoduration} object}
\item{object}{argument for method \code{show}}
\item{quote}{indicates if the output of \code{print} should be
quoted}
\item{...}{further arguments passed to or from methods.}
\item{e1}{Operand of class \code{nanoival}}
\item{e2}{Operand of class \code{nanoival}}
\item{na.rm}{if \code{TRUE} NA values are removed for the
computation}
\item{i}{index specifying elements to extract or replace.}
\item{j}{Required for \code{[} signature but ignored here}
\item{drop}{Required for \code{[} signature but ignored here}
\item{value}{argument for \code{nanoduration-class}}
}
\value{
A nanoduration object
}
\description{
The type \code{nanoduration} is a length of time (implemented as
an S4 class) with nanosecond precision. It is a count of
nanoseconds and may be negative. The expected arithmetic
operations are provided, including sequence generation.
}
\details{
A \code{nanoduration} can be constructed with the function
\code{as.nanoduration} which can take the types \code{integer64},
\code{integer} and \code{numeric} (all indicating the count in
nanosecond units) or the type \code{character}.
It can also be constructed by specifying with individual arguments
the hours, minutes, seconds and nanoseconds with a call to
\code{nanoduration}.
A \code{nanoduration} is displayed as hours, minutes, seconds and
nanoseconds like this: \code{110:12:34.123_453_001}. The nanosecond
precision displayed is adjusted as necessary, so e.g. 1 second is
displayed as \code{00:00:01}.
}
\examples{
## constructors:
nanoduration(hours=10, minutes=3, seconds=2, nanoseconds=999999999)
as.nanoduration("10:03:02.999_999_999")
as.nanoduration(36182999999999)
## arithmetic:
as.nanoduration(10e9) - as.nanoduration(9e9)
as.nanoduration(10e9) + as.nanoduration(-9e9)
as.nanoduration("24:00:00") / 2
as.nanoduration("24:00:00") / as.nanoduration("12:00:00")
## comparison:
as.nanoduration("10:03:02.999_999_999") == 36182999999999
as.nanoduration("10:03:02.999_999_999") > as.nanoduration("10:03:02.999_999_998")
as.nanoduration("10:03:02.999_999_998") < "10:03:02.999_999_999"
}
\seealso{
\code{\link{nanotime}}
}
\author{
Dirk Eddelbuettel
Leonardo Silvestri
}
\keyword{datasets}
| 8,938 | gpl-2.0 |
d7226263791be88336fe7c5d57215b197277f423 | jeffreyhorner/R-Judy-Arrays | src/library/stats/man/power.prop.test.Rd | % File src/library/stats/man/power.prop.test.Rd
% Part of the R package, http://www.R-project.org
% Copyright (C) 1995-2014 R Core Team
% Distributed under GPL 2 or later
\name{power.prop.test}
\alias{power.prop.test}
\encoding{UTF-8}
\title{Power Calculations for Two-Sample Test for Proportions}
\description{
Compute the power of the two-sample test for proportions, or determine
parameters to obtain a target power.
}
\usage{
power.prop.test(n = NULL, p1 = NULL, p2 = NULL, sig.level = 0.05,
power = NULL,
alternative = c("two.sided", "one.sided"),
strict = FALSE, tol = .Machine$double.eps^0.25)
}
\arguments{
\item{n}{number of observations (per group)}
\item{p1}{probability in one group}
\item{p2}{probability in other group}
\item{sig.level}{significance level (Type I error probability)}
\item{power}{power of test (1 minus Type II error probability)}
\item{alternative}{one- or two-sided test}
\item{strict}{use strict interpretation in two-sided case}
\item{tol}{numerical tolerance used in root finding, the default
providing (at least) four significant digits.}
}
\details{
Exactly one of the parameters \code{n}, \code{p1}, \code{p2},
\code{power}, and \code{sig.level} must be passed as NULL, and that
parameter is determined from the others. Notice that \code{sig.level}
has a non-NULL default so NULL must be explicitly passed if you want
it computed.
If \code{strict = TRUE} is used, the power will include the probability of
rejection in the opposite direction of the true effect, in the two-sided
case. Without this the power will be half the significance level if the
true difference is zero.
}
\value{
Object of class \code{"power.htest"}, a list of the arguments
(including the computed one) augmented with \code{method} and
\code{note} elements.
}
\author{Peter Dalgaard. Based on previous work by Claus
\enc{Ekstrøm}{Ekstroem}}
\note{
\code{uniroot} is used to solve power equation for unknowns, so
you may see errors from it, notably about inability to bracket the
root when invalid arguments are given. If one of them is computed
\code{p1 < p2} will hold, although this is not enforced when both are
specified.
}
\seealso{\code{\link{prop.test}}, \code{\link{uniroot}}}
\examples{
power.prop.test(n = 50, p1 = .50, p2 = .75) ## => power = 0.740
power.prop.test(p1 = .50, p2 = .75, power = .90) ## => n = 76.7
power.prop.test(n = 50, p1 = .5, power = .90) ## => p2 = 0.8026
power.prop.test(n = 50, p1 = .5, p2 = 0.9, power = .90, sig.level=NULL)
## => sig.l = 0.00131
power.prop.test(p1 = .5, p2 = 0.501, sig.level=.001, power=0.90)
## => n = 10451937
}
\keyword{ htest }
| 2,829 | gpl-2.0 |
dc0b7059678d97729586d62bacc824e5b6d263ac | radfordneal/pqR | src/library/base/man/agrep.Rd | % File src/library/base/man/agrep.Rd
% Part of the R package, http://www.R-project.org
% Copyright 1995-2011 R Core Team
% Distributed under GPL 2 or later
\name{agrep}
\alias{agrep}
\alias{fuzzy matching}
\alias{.amatch_bounds}
\alias{.amatch_costs}
\title{Approximate String Matching (Fuzzy Matching)}
\description{
Searches for approximate matches to \code{pattern} (the first argument)
within each element of the string \code{x} (the second argument) using
the generalized Levenshtein edit distance (the minimal possibly
weighted number of insertions, deletions and substitutions needed to
transform one string into another).
}
\usage{
agrep(pattern, x, max.distance = 0.1, costs = NULL,
ignore.case = FALSE, value = FALSE, fixed = TRUE,
useBytes = FALSE)
}
\arguments{
\item{pattern}{a non-empty character string or a character string
containing a regular expression (for \code{fixed = FALSE}) to be
matched.
Coerced by \code{\link{as.character}} to a string if possible.}
\item{x}{character vector where matches are sought.
Coerced by \code{\link{as.character}} to a character vector if
possible.}
\item{max.distance}{Maximum distance allowed for a match. Expressed
either as integer, or as a fraction of the \emph{pattern} length
times the maximal transformation cost (will be replaced by the
smallest integer not less than the corresponding fraction), or a
list with possible components
\describe{
\item{\code{cost}:}{maximum number/fraction of match cost
(generalized Levenshtein distance)}
\item{\code{all}:}{maximal number/fraction of \emph{all}
transformations (insertions, deletions and substitutions)}
\item{\code{insertions}:}{maximum number/fraction of insertions}
\item{\code{deletions}:}{maximum number/fraction of deletions}
\item{\code{substitutions}:}{maximum number/fraction of
substitutions}
}
If \code{cost} is not given, \code{all} defaults to 10\%, and the
other transformation number bounds default to \code{all}.
The component names can be abbreviated.
}
\item{costs}{a numeric vector or list with names partially matching
\samp{insertions}, \samp{deletions} and \samp{substitutions} giving
the respective costs for computing the generalized Levenshtein
distance, or \code{NULL} (default) indicating using unit cost for
all three possible transformations.
Coerced to integer via \code{\link{as.integer}} if possible.}
\item{ignore.case}{if \code{FALSE}, the pattern matching is \emph{case
sensitive} and if \code{TRUE}, case is ignored during matching.}
\item{value}{if \code{FALSE}, a vector containing the (integer)
indices of the matches determined is returned and if \code{TRUE}, a
vector containing the matching elements themselves is returned.}
\item{fixed}{logical. If \code{TRUE} (default), the pattern is
matched literally (as is). Otherwise, it is matched as a regular
expression.}
\item{useBytes}{logical. in a multibyte locale, should the comparison
be character-by-character (the default) or byte-by-byte.}
}
\details{
The Levenshtein edit distance is used as measure of approximateness:
it is the (possibly cost-weighted) total number of insertions,
deletions and substitutions required to transform one string into
another.
As from \R 2.10.0 this uses \code{tre} by Ville Laurikari
(\url{http://http://laurikari.net/tre/}), which supports MBCS
character matching much better than the previous version.
The main effect of \code{useBytes} is to avoid errors/warnings about
invalid inputs and spurious matches in multibyte locales.
It inhibits the conversion of inputs with marked encodings, and is
forced if any input is found which is marked as \code{"bytes"}.
}
\note{
Since someone who read the description carelessly even filed a bug
report on it, do note that this matches substrings of each element of
\code{x} (just as \code{\link{grep}} does) and \bold{not} whole
elements. See \code{\link{adist}} in package \pkg{utils}, which
optionally returns the offsets of the matched substrings.
}
\value{
Either a vector giving the indices of the elements that yielded a
match, or, if \code{value} is \code{TRUE}, the matched elements (after
coercion, preserving names but no other attributes).
}
\author{
Original version by David Meyer.
Current version by Brian Ripley and Kurt Hornik.
}
\seealso{
\code{\link{grep}}
}
\examples{
agrep("lasy", "1 lazy 2")
agrep("lasy", c(" 1 lazy 2", "1 lasy 2"), max = list(sub = 0))
agrep("laysy", c("1 lazy", "1", "1 LAZY"), max = 2)
agrep("laysy", c("1 lazy", "1", "1 LAZY"), max = 2, value = TRUE)
agrep("laysy", c("1 lazy", "1", "1 LAZY"), max = 2, ignore.case = TRUE)
}
\keyword{character}
| 4,809 | gpl-2.0 |
510bd128a4403ebcb28712a10e7d8c3aea8e0e15 | cran/FSA | man/capFirst.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/FSAUtils.R
\name{capFirst}
\alias{capFirst}
\title{Capitalizes the first letter of first or all words in a string.}
\usage{
capFirst(x, which = c("all", "first"))
}
\arguments{
\item{x}{A single string.}
\item{which}{A single string that indicates whether all (the default) or only the first words should be capitalized.}
}
\value{
A single string with the first letter of the first or all words capitalized.
}
\description{
Capitalizes the first letter of first or all words in a string.
}
\examples{
## Capitalize first letter of all words (the default)
capFirst("Derek Ogle")
capFirst("derek ogle")
capFirst("derek")
## Capitalize first letter of only the first words
capFirst("Derek Ogle",which="first")
capFirst("derek ogle",which="first")
capFirst("derek",which="first")
## apply to all elements in a vector
vec <- c("Derek Ogle","derek ogle","Derek ogle","derek Ogle","DEREK OGLE")
capFirst(vec)
capFirst(vec,which="first")
## check class types
class(vec)
vec1 <- capFirst(vec)
class(vec1)
fvec <- factor(vec)
fvec1 <- capFirst(fvec)
class(fvec1)
}
\author{
Derek H. Ogle, \email{[email protected]}
}
\keyword{manip}
| 1,255 | gpl-2.0 |
081e0581ffac62f3844ccf2ada4e77ee3eccd1d7 | Groupe-ElementR/cartography | man/propSymbolsChoroLayer.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/propSymbolsChoroLayer.R
\name{propSymbolsChoroLayer}
\alias{propSymbolsChoroLayer}
\title{Proportional and Choropleth Symbols Layer}
\usage{
propSymbolsChoroLayer(x, spdf, df, spdfid = NULL, dfid = NULL, var,
inches = 0.3, fixmax = NULL, symbols = "circle",
border = "grey20", lwd = 1, var2, breaks = NULL,
method = "quantile", nclass = NULL, col = NULL, colNA = "white",
legend.title.cex = 0.8, legend.values.cex = 0.6,
legend.var.pos = "right", legend.var.title.txt = var,
legend.var.values.rnd = 0, legend.var.style = "c",
legend.var.frame = FALSE, legend.var2.pos = "topright",
legend.var2.title.txt = var2, legend.var2.values.rnd = 2,
legend.var2.nodata = "no data", legend.var2.frame = FALSE,
legend.var2.border = "black", legend.var2.horiz = FALSE,
add = TRUE)
}
\arguments{
\item{x}{an sf object, a simple feature collection. If x is used then spdf, df, spdfid and dfid are not.}
\item{spdf}{SpatialPointsDataFrame or SpatialPolygonsDataFrame; if spdf
is a SpatialPolygonsDataFrame symbols are plotted on centroids.}
\item{df}{a data frame that contains the values to plot. If df is missing
spdf@data is used instead.}
\item{spdfid}{identifier field in spdf, default to the first column
of the spdf data frame. (optional)}
\item{dfid}{identifier field in df, default to the first column
of df. (optional)}
\item{var}{name of the numeric field in df to plot the symbols sizes.}
\item{inches}{size of the biggest symbol (radius for circles, width for
squares, height for bars) in inches.}
\item{fixmax}{value of the biggest symbol (see \link{propSymbolsLayer} Details).}
\item{symbols}{type of symbols, one of "circle", "square" or "bar".}
\item{border}{color of symbols borders.}
\item{lwd}{width of symbols borders.}
\item{var2}{name of the numeric field in df to plot the colors.}
\item{breaks}{break points in sorted order to indicate the intervals for assigning the colors.
Note that if there are nlevel colors (classes) there should be (nlevel+1)
breakpoints (see \link{choroLayer} Details).}
\item{method}{a classification method; one of "sd", "equal",
"quantile", "fisher-jenks", "q6" or "geom" (see \link{choroLayer} Details).}
\item{nclass}{a targeted number of classes. If null, the number of class is
automatically defined (see \link{choroLayer} Details).}
\item{col}{a vector of colors. Note that if breaks is specified there must be one less
colors specified than the number of break.}
\item{colNA}{no data color.}
\item{legend.title.cex}{size of the legend title.}
\item{legend.values.cex}{size of the values in the legend.}
\item{legend.var.pos}{position of the legend, one of "topleft", "top",
"topright", "right", "bottomright", "bottom", "bottomleft", "left" or a
vector of two coordinates in map units (c(x, y)). If
legend.var.pos is "n" then the legend is not plotted.}
\item{legend.var.title.txt}{title of the legend (proportional symbols).}
\item{legend.var.values.rnd}{number of decimal places of the values in
the legend.}
\item{legend.var.style}{either "c" or "e". The legend has two display
styles.}
\item{legend.var.frame}{whether to add a frame to the legend (TRUE) or
not (FALSE).}
\item{legend.var2.pos}{position of the legend, one of "topleft", "top",
"topright", "right", "bottomright", "bottom", "bottomleft", "left" or a
vector of two coordinates in map units (c(x, y)). If
legend.var2.pos is "n" then the legend is not plotted.}
\item{legend.var2.title.txt}{title of the legend (colors).}
\item{legend.var2.values.rnd}{number of decimal places of the values in
the legend.}
\item{legend.var2.nodata}{text for "no data" values}
\item{legend.var2.frame}{whether to add a frame to the legend (TRUE) or
not (FALSE).}
\item{legend.var2.border}{color of boxes borders in the legend.}
\item{legend.var2.horiz}{whether to display the legend horizontally (TRUE) or
not (FALSE).}
\item{add}{whether to add the layer to an existing plot (TRUE) or
not (FALSE).}
}
\description{
Plot a proportional symbols layer with colors based on a
quantitative data classification
}
\examples{
library(sf)
mtq <- st_read(system.file("gpkg/mtq.gpkg", package="cartography"))
plot(st_geometry(mtq), col = "grey60",border = "white",
lwd=0.4, bg = "lightsteelblue1")
propSymbolsChoroLayer(x = mtq, var = "POP", var2 = "MED",
col = carto.pal(pal1 = "blue.pal", n1 = 3,
pal2 = "red.pal", n2 = 3),
inches = 0.2, method = "q6",
border = "grey50", lwd = 1,
legend.var.pos = "topright",
legend.var2.pos = "left",
legend.var2.values.rnd = -2,
legend.var2.title.txt = "Median Income\\n(in euros)",
legend.var.title.txt = "Total Population",
legend.var.style = "e")
# First layout
layoutLayer(title="Population and Wealth in Martinique, 2015")
}
\seealso{
\link{legendBarsSymbols}, \link{legendChoro},
\link{legendCirclesSymbols}, \link{legendSquaresSymbols},
\link{choroLayer}, \link{propSymbolsLayer}
}
| 5,207 | gpl-3.0 |
6a075b633478d305579472602a606fc9194b10d2 | jbrzusto/motusServer | man/handleSGfiles.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/handleSGfiles.R
\name{handleSGfiles}
\alias{handleSGfiles}
\title{handle a folder of files from one or more sensorgnomes}
\usage{
handleSGfiles(j)
}
\arguments{
\item{j}{the job with these item(s):
\itemize{
\item filePath; path to files to be merged; if NULL, defaults to \code{jobPath(j)}
}}
}
\value{
TRUE
}
\description{
Called by \code{\link{processServer}} for files from a sensorgnome
}
\details{
For each unique SG serial number found among the names of
the incoming files, queue a subjob for each boot session having
data files.
}
\note{
if \code{topJob(j)$mergeOnly)} is TRUE, then only merge files
into receiver databases; don't run the tag finder.
}
\seealso{
\link{\code{processServer}}
}
\author{
John Brzustowski \email{jbrzusto@REMOVE_THIS_PART_fastmail.fm}
}
| 865 | gpl-2.0 |
1c28b0c4359f3eb72ab22fbe6b68b0a4a94ff259 | tijoseymathew/mlr | man/getHomogeneousEnsembleModels.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/HomogeneousEnsemble.R
\name{getHomogeneousEnsembleModels}
\alias{getHomogeneousEnsembleModels}
\title{Deprecated, use \code{getLearnerModel} instead.}
\usage{
getHomogeneousEnsembleModels(model, learner.models = FALSE)
}
\arguments{
\item{model}{Deprecated.}
\item{learner.models}{Deprecated.}
}
\description{
Deprecated, use \code{getLearnerModel} instead.
}
| 439 | bsd-2-clause |
d7226263791be88336fe7c5d57215b197277f423 | jeffreyhorner/R-Array-Hash | src/library/stats/man/power.prop.test.Rd | % File src/library/stats/man/power.prop.test.Rd
% Part of the R package, http://www.R-project.org
% Copyright (C) 1995-2014 R Core Team
% Distributed under GPL 2 or later
\name{power.prop.test}
\alias{power.prop.test}
\encoding{UTF-8}
\title{Power Calculations for Two-Sample Test for Proportions}
\description{
Compute the power of the two-sample test for proportions, or determine
parameters to obtain a target power.
}
\usage{
power.prop.test(n = NULL, p1 = NULL, p2 = NULL, sig.level = 0.05,
power = NULL,
alternative = c("two.sided", "one.sided"),
strict = FALSE, tol = .Machine$double.eps^0.25)
}
\arguments{
\item{n}{number of observations (per group)}
\item{p1}{probability in one group}
\item{p2}{probability in other group}
\item{sig.level}{significance level (Type I error probability)}
\item{power}{power of test (1 minus Type II error probability)}
\item{alternative}{one- or two-sided test}
\item{strict}{use strict interpretation in two-sided case}
\item{tol}{numerical tolerance used in root finding, the default
providing (at least) four significant digits.}
}
\details{
Exactly one of the parameters \code{n}, \code{p1}, \code{p2},
\code{power}, and \code{sig.level} must be passed as NULL, and that
parameter is determined from the others. Notice that \code{sig.level}
has a non-NULL default so NULL must be explicitly passed if you want
it computed.
If \code{strict = TRUE} is used, the power will include the probability of
rejection in the opposite direction of the true effect, in the two-sided
case. Without this the power will be half the significance level if the
true difference is zero.
}
\value{
Object of class \code{"power.htest"}, a list of the arguments
(including the computed one) augmented with \code{method} and
\code{note} elements.
}
\author{Peter Dalgaard. Based on previous work by Claus
\enc{Ekstrøm}{Ekstroem}}
\note{
\code{uniroot} is used to solve power equation for unknowns, so
you may see errors from it, notably about inability to bracket the
root when invalid arguments are given. If one of them is computed
\code{p1 < p2} will hold, although this is not enforced when both are
specified.
}
\seealso{\code{\link{prop.test}}, \code{\link{uniroot}}}
\examples{
power.prop.test(n = 50, p1 = .50, p2 = .75) ## => power = 0.740
power.prop.test(p1 = .50, p2 = .75, power = .90) ## => n = 76.7
power.prop.test(n = 50, p1 = .5, power = .90) ## => p2 = 0.8026
power.prop.test(n = 50, p1 = .5, p2 = 0.9, power = .90, sig.level=NULL)
## => sig.l = 0.00131
power.prop.test(p1 = .5, p2 = 0.501, sig.level=.001, power=0.90)
## => n = 10451937
}
\keyword{ htest }
| 2,829 | gpl-2.0 |
87968ee028437fac6acb43572a674b9937bf60ed | pet-estatistica/labestData | man/DiasEx11.7.8.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/Dias.R
\name{DiasEx11.7.8}
\alias{DiasEx11.7.8}
\title{Competi\enc{çã}{ca}o de Gen\enc{ó}{o}tipos de Alho}
\format{Um \code{data.frame} com 16 observações e 3 variáveis, em que
\describe{
\item{\code{geno}}{Fator categórico que representa os genótipos de
alho.}
\item{\code{exper}}{Fator categórico que representa os experimentos.}
\item{\code{prod}}{Produção de bulbos de alho.}
}}
\source{
BARROS; DIAS (2009), Exercício 8, Cap. 11, pág. 321.
}
\description{
Resultados de um grupo de experimento de competiação de
genótipos de alho. Os valores disponíveis são as médias dos
genótipos em cada experimento.
}
\examples{
library(lattice)
data(DiasEx11.7.8)
str(DiasEx11.7.8)
xtabs(~geno + exper, data = DiasEx11.7.8)
# Totais.
with(DiasEx11.7.8,
addmargins(tapply(prod,
list(geno = geno, exper = exper),
FUN = sum)))
xyplot(prod ~ geno, groups = exper, data = DiasEx11.7.8,
type = c("p", "a"),
xlab = "Genótipos",
ylab = "Produção",
auto.key = list(title = "Experimentos", cex.title = 1.1,
columns = 4))
}
\keyword{GE}
| 1,247 | gpl-3.0 |
1c28b0c4359f3eb72ab22fbe6b68b0a4a94ff259 | vinaywv/mlr | man/getHomogeneousEnsembleModels.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/HomogeneousEnsemble.R
\name{getHomogeneousEnsembleModels}
\alias{getHomogeneousEnsembleModels}
\title{Deprecated, use \code{getLearnerModel} instead.}
\usage{
getHomogeneousEnsembleModels(model, learner.models = FALSE)
}
\arguments{
\item{model}{Deprecated.}
\item{learner.models}{Deprecated.}
}
\description{
Deprecated, use \code{getLearnerModel} instead.
}
| 439 | bsd-2-clause |
6a075b633478d305579472602a606fc9194b10d2 | jbrzusto/motus-R-package | man/handleSGfiles.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/handleSGfiles.R
\name{handleSGfiles}
\alias{handleSGfiles}
\title{handle a folder of files from one or more sensorgnomes}
\usage{
handleSGfiles(j)
}
\arguments{
\item{j}{the job with these item(s):
\itemize{
\item filePath; path to files to be merged; if NULL, defaults to \code{jobPath(j)}
}}
}
\value{
TRUE
}
\description{
Called by \code{\link{processServer}} for files from a sensorgnome
}
\details{
For each unique SG serial number found among the names of
the incoming files, queue a subjob for each boot session having
data files.
}
\note{
if \code{topJob(j)$mergeOnly)} is TRUE, then only merge files
into receiver databases; don't run the tag finder.
}
\seealso{
\link{\code{processServer}}
}
\author{
John Brzustowski \email{jbrzusto@REMOVE_THIS_PART_fastmail.fm}
}
| 865 | gpl-2.0 |
d7226263791be88336fe7c5d57215b197277f423 | o-/Rexperiments | src/library/stats/man/power.prop.test.Rd | % File src/library/stats/man/power.prop.test.Rd
% Part of the R package, http://www.R-project.org
% Copyright (C) 1995-2014 R Core Team
% Distributed under GPL 2 or later
\name{power.prop.test}
\alias{power.prop.test}
\encoding{UTF-8}
\title{Power Calculations for Two-Sample Test for Proportions}
\description{
Compute the power of the two-sample test for proportions, or determine
parameters to obtain a target power.
}
\usage{
power.prop.test(n = NULL, p1 = NULL, p2 = NULL, sig.level = 0.05,
power = NULL,
alternative = c("two.sided", "one.sided"),
strict = FALSE, tol = .Machine$double.eps^0.25)
}
\arguments{
\item{n}{number of observations (per group)}
\item{p1}{probability in one group}
\item{p2}{probability in other group}
\item{sig.level}{significance level (Type I error probability)}
\item{power}{power of test (1 minus Type II error probability)}
\item{alternative}{one- or two-sided test}
\item{strict}{use strict interpretation in two-sided case}
\item{tol}{numerical tolerance used in root finding, the default
providing (at least) four significant digits.}
}
\details{
Exactly one of the parameters \code{n}, \code{p1}, \code{p2},
\code{power}, and \code{sig.level} must be passed as NULL, and that
parameter is determined from the others. Notice that \code{sig.level}
has a non-NULL default so NULL must be explicitly passed if you want
it computed.
If \code{strict = TRUE} is used, the power will include the probability of
rejection in the opposite direction of the true effect, in the two-sided
case. Without this the power will be half the significance level if the
true difference is zero.
}
\value{
Object of class \code{"power.htest"}, a list of the arguments
(including the computed one) augmented with \code{method} and
\code{note} elements.
}
\author{Peter Dalgaard. Based on previous work by Claus
\enc{Ekstrøm}{Ekstroem}}
\note{
\code{uniroot} is used to solve power equation for unknowns, so
you may see errors from it, notably about inability to bracket the
root when invalid arguments are given. If one of them is computed
\code{p1 < p2} will hold, although this is not enforced when both are
specified.
}
\seealso{\code{\link{prop.test}}, \code{\link{uniroot}}}
\examples{
power.prop.test(n = 50, p1 = .50, p2 = .75) ## => power = 0.740
power.prop.test(p1 = .50, p2 = .75, power = .90) ## => n = 76.7
power.prop.test(n = 50, p1 = .5, power = .90) ## => p2 = 0.8026
power.prop.test(n = 50, p1 = .5, p2 = 0.9, power = .90, sig.level=NULL)
## => sig.l = 0.00131
power.prop.test(p1 = .5, p2 = 0.501, sig.level=.001, power=0.90)
## => n = 10451937
}
\keyword{ htest }
| 2,829 | gpl-2.0 |
f2c38403b53ccc4358373d1045e27dc4773e2c7e | willpearse/pez | man/scape.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/scape.R
\name{scape}
\alias{scape}
\title{Simulate phylogenetic community structure across a landscape}
\usage{
scape(tree, scape.size = 10, g.center = 1, g.range = 1,
g.repulse = 1, wd.all = 150, signal.center = TRUE,
signal.range = TRUE, same.range = TRUE, repulse = TRUE,
center.scale = 1, range.scale = 1, repulse.scale = 1,
site.stoch.scale = 0.5, sd.center = 1, sd.range = 1, rho = NULL,
th = 8)
}
\arguments{
\item{tree}{\code{\link{phylo}} object}
\item{scape.size}{edge dimension of square landscape}
\item{g.center}{strength of phylogenetic signal in species range centers}
\item{g.range}{strength of phylogenetic signal in species range sizes}
\item{g.repulse}{strength of phylogenetic repulsion}
\item{wd.all}{niche width, larger values simulate broader range sizes}
\item{signal.center}{simulate with phylosignal in range centers}
\item{signal.range}{simulate with phylosignal in range size}
\item{same.range}{make all range sizes equal}
\item{repulse}{include phylogenetic repulsion in range centers}
\item{center.scale}{adjust strength of phylogenetic attraction in
range centers independent of \code{g.center}}
\item{range.scale}{adjust strength of phylogenetic signal in range
size independent of \code{g.range}}
\item{repulse.scale}{adjust strength of phylogenetic repulsion
independent of \code{g.repulse}}
\item{site.stoch.scale}{adjust strength of random variation in
species richness across sites}
\item{sd.center}{sd in \code{\link{rnorm}} for the range centers,
increase to get more variation in center values across species}
\item{sd.range}{sd \code{\link{rnorm}} for the range sizes,
increase to get more variation in range sizes across gradients}
\item{rho}{Grafen branch adjustment of phylogenetic tree see
\code{\link{corGrafen}}}
\item{th}{probability threshold 10^-th above which species are
considered present at a site}
}
\value{
\item{cc}{\code{\link{comparative.comm}} object with presence/absence
results of simulations. The site names are the row.columns of the
cells in the original grid cells that made up the data, and these
co-ordinates are also given in the \code{env} slot of the object.}
\item{X.joint}{full probabilities of species at sites, used
to construct \code{cc}}
\item{X1}{probabilities of species along gradient 1}
\item{X2}{probabilities of species along gradient 2}
\item{sppXs}{full probabilities of each species as an array
arranged in a \code{scape.size}-by-\code{scape.size} matrix}
\item{V.phylo}{initial phylogenetic covariance matrix from
tree}
\item{V.phylo.rho}{phylogenetic covariance matrix from tree
scaled by Grafen if rho is provided}
\item{V.center}{scaled by \code{g.center} phylo covariance
matrix used in the simulations}
\item{V.range}{scaled by \code{g.range} phylo covariance
matrix used in the simulations}
\item{V.repulse}{scaled by \code{g.repulse} phylo
covariance matrix used in the simulations}
\item{bspp1}{species optima for gradient 1}
\item{bspp2}{species optima for gradient 2}
\item{u}{the env gradients values for the two gradients}
\item{wd}{the denominator for species ranges}
}
\description{
\code{scape} simulates communities that are phylogenetically structured
}
\details{
Simulates a landscape with species (i.e., tree tips)
distributions dependent on a supplied phylogenetic tree. The
amount and type of structure is determened by the signal parameters
\code{g.center}, \code{g.range} and \code{g.repulse}. Parameters
are based on an Ornstein-Uhlenbeck model of evolution with
stabilizing selection. Values of g=1 indicate no stabilizing
selection and correspond to the Brownian motion model of evolution;
0<g<1 represents stabilizing selection; and g>1 corresponds to
disruptive selection where phylogenetic signal for the supplied
tree is amplified. See \code{\link{corBlomberg}}. Communities are
simulated along two gradients where the positions along those
gradients, \code{g.center} and range sizes \code{g.range}, can
exhibit phylogenetic signal. Phylogenetic attraction is simulated
in the \code{g.center} paramter, while repulsion in
\code{g.repulse}. Both can be exhibited such that closly related
species are generally found with similar range centers
(phylogenetic attraction) but just not at the same site
(phylogenetic repulsion). The function then returns probabilities
of of each species across sites and the presence and absences of
species based a supplied threshold, \code{th}, which can be
increased to obtain more species at sites and thus increase average
site species richness.
}
\examples{
#Create balanced tree with equal branch-lengths (signal in centers)
tree <- stree(8,type="balanced")
tree$edge.length <- rep(1, nrow(tree$edge))
tree$root <- 1
kk <- scape(tree, scape.size=100, g.center=100, g.range=1, g.repulse=1, wd.all=150,
signal.center=TRUE, signal.range=FALSE, same.range=FALSE, repulse=FALSE,center.scale = 1,
range.scale = 1, repulse.scale = 1, site.stoch.scale = 0, sd.center=3, sd.range=1,
rho=NULL, th=20)
#Make some plots
par(mfrow=c(1,Ntip(tree)),mar=c(.1,.1,.1,.1))
for(j in seq_along(tree$tip.label))
image(t(1 - kk$sppXs[,,j]/max(kk$sppXs[,,j])), xlab = "",
ylab = "",main = "",axes=FALSE, col=grey.colors(10))
par(mfrow=c(2,1))
matplot((kk$X1), type = "l", xlab="gradient",ylab = "probability",
main = "Gradient 1",col=rainbow(dim(kk$X1)[2]),lty=1)
matplot((kk$X2), type = "l", xlab="gradient",ylab = "probability",
main = "Gradient 2",col=rainbow(dim(kk$X2)[2]),lty=1)
plot(x=seq_along(sites(kk$cc)),y = rowSums(comm(kk$cc)), main = "SR",type = "l")
cor(kk$X1)
}
\references{
Helmus M.R. & Ives A.R. (2012). Phylogenetic diversity
area curves. Ecology, 93, S31-S43.
}
\seealso{
\code{\link{eco.scape}} \code{\link{sim.phy}}
\code{\link{sim.meta}}
}
\author{
M.R. Helmus, cosmetic changes by Will Pearse
}
| 5,922 | gpl-3.0 |
a2214c863af05783e74ec38b9147c0d757075ba1 | gavinha/TitanCNA | man/filterData.Rd | \name{filterData}
\alias{filterData}
\title{
Filter list object based on read depth and missing data and returns a filtered \link[data.table]{data.table} object.
}
\description{
Filters all vectors in list based on specified chromosome(s) of interest, minimum and maximum read depths, missing data, mappability score threshold
}
\usage{
filterData(data ,chrs = NULL, minDepth = 10, maxDepth = 200,
positionList = NULL, map = NULL, mapThres = 0.9,
centromeres = NULL, centromere.flankLength = 0)
}
\arguments{
\item{data}{
\link[data.table]{data.table} object that contains an arbitrary number of components. Should include \sQuote{chr}, \sQuote{tumDepth}. All vector elements must have the same number of rows where each row corresponds to information pertaining to a chromosomal position.
}
\item{chrs}{
\code{character} or vector of \code{character} specifying the chromosomes to keep. Chromosomes not included in this \code{array} will be filtered out. Chromosome style must match the \code{genomeStyle} used when running \code{\link{loadAlleleCounts}}
}
\item{minDepth}{
\code{Numeric integer} specifying the minimum tumour read depth to include. Positions >= \code{minDepth} are kept.
}
\item{maxDepth}{
\code{Numeric integer} specifying the maximum tumour read depth to include. Positions <= \code{maxDepth} are kept.
}
\item{positionList}{
\code{\link[base:data.frame]{data.frame}} with two columns: \sQuote{chr} and \sQuote{posn}. \code{positionList} lists the chromosomal positions to use in the analysis. All positions not overlapping this list will be excluded. Use \code{NULL} to use all current positions in \code{data}.
}
\item{map}{
\code{Numeric array} containing map scores corresponding to each position in \code{data}. Optional for filtering positions based on mappability scores.
}
\item{mapThres}{
\code{Numeric float} specifying the mappability score threshold. Only applies if \code{map} is specified. \code{map} scores >= \code{mapThres} are kept.
}
\item{centromeres}{
data.frame containing list of centromere regions. This should contain 3 columns: chr, start, and end. If this argument is used, then data at and flanking the centromeres will be removed.
}
\item{centromere.flankLength}{
Integer indicating the length (in base pairs) to the left and to the right of the centromere designated for removal of data.
}
}
\details{
All vectors in the input \link[data.table]{data.table} object, and \code{map}, must all have the same number of rows.
}
\value{
The same \code{\link[data.table]{data.table}} object containing filtered components.
}
\references{
Ha, G., Roth, A., Khattra, J., Ho, J., Yap, D., Prentice, L. M., Melnyk, N., McPherson, A., Bashashati, A., Laks, E., Biele, J., Ding, J., Le, A., Rosner, J., Shumansky, K., Marra, M. A., Huntsman, D. G., McAlpine, J. N., Aparicio, S. A. J. R., and Shah, S. P. (2014). TITAN: Inference of copy number architectures in clonal cell populations from tumour whole genome sequence data. Genome Research, 24: 1881-1893. (PMID: 25060187)
}
\author{
Gavin Ha <[email protected]>
}
\seealso{
\code{\link{loadAlleleCounts}}
}
\examples{
infile <- system.file("extdata", "test_alleleCounts_chr2.txt",
package = "TitanCNA")
tumWig <- system.file("extdata", "test_tum_chr2.wig", package = "TitanCNA")
normWig <- system.file("extdata", "test_norm_chr2.wig", package = "TitanCNA")
gc <- system.file("extdata", "gc_chr2.wig", package = "TitanCNA")
map <- system.file("extdata", "map_chr2.wig", package = "TitanCNA")
#### LOAD DATA ####
data <- loadAlleleCounts(infile, genomeStyle = "NCBI")
#### GC AND MAPPABILITY CORRECTION ####
cnData <- correctReadDepth(tumWig, normWig, gc, map)
#### READ COPY NUMBER FROM HMMCOPY FILE ####
logR <- getPositionOverlap(data$chr, data$posn, cnData)
data$logR <- log(2^logR) #use natural logs
#### FILTER DATA FOR DEPTH, MAPPABILITY, NA, etc ####
filtereData <- filterData(data, as.character(1:24), minDepth = 10,
maxDepth = 200, map = NULL, mapThres=0.9)
}
\keyword{manip}
| 4,112 | gpl-3.0 |
333ea2e5a7d10a1b6fa524da8eae556f839fd6a0 | Shians/Glimma | man/glMDPlot.MArrayLM.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/glMDPlot.R
\name{glMDPlot.MArrayLM}
\alias{glMDPlot.MArrayLM}
\title{Glimma MD Plot}
\usage{
\method{glMDPlot}{MArrayLM}(
x,
counts = NULL,
anno = NULL,
groups = NULL,
samples = NULL,
status = rep(0, nrow(x)),
transform = FALSE,
main = "",
xlab = "Average log CPM",
ylab = "log-fold-change",
side.main = "GeneID",
side.xlab = "Group",
side.ylab = "Expression",
side.log = FALSE,
side.gridstep = ifelse(!transform || side.log, FALSE, 0.5),
coef = ncol(x$coefficients),
p.adj.method = "BH",
jitter = 30,
display.columns = NULL,
cols = c("#00bfff", "#858585", "#ff3030"),
sample.cols = rep("#1f77b4", ncol(counts)),
path = getwd(),
folder = "glimma-plots",
html = "MD-Plot",
launch = TRUE,
...
)
}
\arguments{
\item{x}{the MArrayLM object.}
\item{counts}{the matrix of expression values, with samples in columns.}
\item{anno}{the data.frame containing gene annotations.}
\item{groups}{the factor containing experimental groups of the samples.}
\item{samples}{the names of the samples.}
\item{status}{vector giving the control status of data point, of same length
as the number of rows of object. If NULL, then all points are plotted in
the default colour.}
\item{transform}{TRUE if counts should be log-cpm transformed.}
\item{main}{the title for the left plot.}
\item{xlab}{label for x axis on left plot.}
\item{ylab}{label for y axis on left plot.}
\item{side.main}{the column containing mains for right plot.}
\item{side.xlab}{label for x axis on right plot.}
\item{side.ylab}{label for y axis on right plot.}
\item{side.log}{TRUE to plot expression on the right plot on log scale.}
\item{side.gridstep}{intervals along which to place grid lines on y axis.
Currently only available for linear scale.}
\item{coef}{integer or character index vector indicating which column of object to plot.}
\item{p.adj.method}{character vector indicating multiple testing correction method. See \code{\link{p.adjust}} for available methods. (defaults to "BH")}
\item{jitter}{the amount of jitter to apply to the samples in the expressions
plot.}
\item{display.columns}{character vector containing names of columns to
display in mouseover tooltips and table.}
\item{cols}{vector of strings denoting colours corresponding to control
status -1, 0 and 1. (may be R named colours or Hex values)}
\item{sample.cols}{vector of strings denoting colours for each sample point
on the expression plot.}
\item{path}{the path in which the folder will be created.}
\item{folder}{the name of the fold to save html file to.}
\item{html}{the name of the html file to save plots to.}
\item{launch}{TRUE to launch plot after call.}
\item{...}{additional arguments to be passed onto the MD plot. (main, xlab,
ylab can be set for the left plot)}
}
\value{
Draws a two-panel interactive MD plot in an html page. The left plot
shows the log-fold-change vs average expression. The right plot shows the
expression levels of a particular gene of each sample. Hovering over points
on left plot will plot expression level for corresponding gene, clicking on
points will fix the expression plot to gene. Clicking on rows on the table
has the same effect as clicking on the corresponding gene in the plot.
}
\description{
Draw an interactive MD plot from a MArrayLM object
}
\examples{
\donttest{
library(limma)
library(edgeR)
data(lymphomaRNAseq)
x <- lymphomaRNAseq
sel <- rowSums(cpm(x$counts)>0.5)>=3
x <- x[sel,]
genotype <- relevel(x$samples$group, "Smchd1-null")
x <- calcNormFactors(x, method="TMM")
des <- model.matrix(~genotype)
## Apply voom with sample quality weights and fit linear model
v <- voomWithQualityWeights(x, design=des, plot=FALSE)
vfit <- lmFit(v,des)
## Apply treat relative to a fold-change of 1.5
vtfit <- treat(vfit,lfc=log2(1.5))
vfit <- eBayes(vfit)
results <- decideTests(vfit,p.value=0.01)
glMDPlot(vfit, counts=x$counts, anno=x$genes, groups=genotype, samples=1:7,
status=results[,2], main="MD plot: Wild-type vs Smchd1",
display.columns=c("Symbols", "GeneID", "GeneName"),
folder="Smchd1-Lymphoma")
}
}
\author{
Shian Su
}
| 4,212 | lgpl-3.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | PawarPawan/h2o-v3 | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
9bfc705d852b828e848607138889b09558660633 | abiyug/r-source | src/library/methods/man/setSClass.Rd | % File src/library/methods/man/setSClass.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{makeClassRepresentation}
\alias{makeClassRepresentation}
\title{Create a Class Definition}
\description{
Constructs an object of class \code{\linkS4class{classRepresentation}}
to describe a particular class. Mostly a utility function, but you can
call it to create a class definition without assigning it, as
\code{\link{setClass}} would do.
}
\usage{
makeClassRepresentation(name, slots=list(), superClasses=character(),
prototype=NULL, package, validity, access,
version, sealed, virtual=NA, where)
}
\arguments{
\item{name}{character string name for the class}
\item{slots}{named list of slot classes as would be supplied to
\code{setClass}, but \emph{without} the unnamed arguments for
superClasses if any.}
\item{superClasses}{what classes does this class extend}
\item{prototype}{an object providing the default data for the class,
e.g, the result of a call to \code{\link{prototype}}.}
\item{package}{The character string name for the package in which
the class will be stored; see \code{\link{getPackageName}}.}
\item{validity}{Optional validity method. See
\code{\link{validObject}}, and the discussion of validity methods in
the reference.}
\item{access}{Access information. Not currently used.}
\item{version}{Optional version key for version control. Currently
generated, but not used.}
\item{sealed}{Is the class sealed? See \code{\link{setClass}}.}
\item{virtual}{Is this known to be a virtual class?}
\item{where}{The environment from which to look for class
definitions needed (e.g., for slots or superclasses). See the
discussion of this argument under \link{GenericFunctions}.}
}
\references{
Chambers, John M. (2008)
\emph{Software for Data Analysis: Programming with R}
Springer. (For the R version.)
Chambers, John M. (1998)
\emph{Programming with Data}
Springer (For the original S4 version.)
}
\seealso{
\code{\link{setClass}}
}
\keyword{programming}
\keyword{classes}
| 2,197 | gpl-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | printedheart/h2o-3 | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | h2oai/h2o | R/h2o-package/man/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | 100star/h2o | R/h2o-package/man/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
9bfc705d852b828e848607138889b09558660633 | LeifAndersen/R | src/library/methods/man/setSClass.Rd | % File src/library/methods/man/setSClass.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{makeClassRepresentation}
\alias{makeClassRepresentation}
\title{Create a Class Definition}
\description{
Constructs an object of class \code{\linkS4class{classRepresentation}}
to describe a particular class. Mostly a utility function, but you can
call it to create a class definition without assigning it, as
\code{\link{setClass}} would do.
}
\usage{
makeClassRepresentation(name, slots=list(), superClasses=character(),
prototype=NULL, package, validity, access,
version, sealed, virtual=NA, where)
}
\arguments{
\item{name}{character string name for the class}
\item{slots}{named list of slot classes as would be supplied to
\code{setClass}, but \emph{without} the unnamed arguments for
superClasses if any.}
\item{superClasses}{what classes does this class extend}
\item{prototype}{an object providing the default data for the class,
e.g, the result of a call to \code{\link{prototype}}.}
\item{package}{The character string name for the package in which
the class will be stored; see \code{\link{getPackageName}}.}
\item{validity}{Optional validity method. See
\code{\link{validObject}}, and the discussion of validity methods in
the reference.}
\item{access}{Access information. Not currently used.}
\item{version}{Optional version key for version control. Currently
generated, but not used.}
\item{sealed}{Is the class sealed? See \code{\link{setClass}}.}
\item{virtual}{Is this known to be a virtual class?}
\item{where}{The environment from which to look for class
definitions needed (e.g., for slots or superclasses). See the
discussion of this argument under \link{GenericFunctions}.}
}
\references{
Chambers, John M. (2008)
\emph{Software for Data Analysis: Programming with R}
Springer. (For the R version.)
Chambers, John M. (1998)
\emph{Programming with Data}
Springer (For the original S4 version.)
}
\seealso{
\code{\link{setClass}}
}
\keyword{programming}
\keyword{classes}
| 2,197 | gpl-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | mrgloom/h2o-3 | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | eg-zhang/h2o-2 | R/h2o-package/man/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
01ced1f52db0859a76d14ca22869ab484afe2d12 | eduardohet/resulteR | man/meansdText.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/meansdText.R
\name{meansdText}
\alias{meansdText}
\title{Generates strings of text for the use in markdown documents}
\usage{
meansdText(x, dec = "default", digits = c(1, 1))
}
\arguments{
\item{x}{A numeric vector}
\item{dec}{Which decimal separator should be used? Defaults to ".". Allows to quickly changing to a comma in case you are producing a manuscript in German or Portuguese.}
\item{digits}{How many digits should be kept for each piece of numeric information? Defaults to c(1, 1).}
}
\value{
A string of text to be included in a markdown object.
}
\description{
This function takes as input one vector and returns its mean and standard deviation in the most standard notation (mean ± sd).
}
\examples{
x <- rnorm(50, mean=10, sd=20)
meansdText(x)
# Rounding
meansdText(x, digits=c(3, 3))
}
| 910 | gpl-3.0 |
9bfc705d852b828e848607138889b09558660633 | nathan-russell/r-source | src/library/methods/man/setSClass.Rd | % File src/library/methods/man/setSClass.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{makeClassRepresentation}
\alias{makeClassRepresentation}
\title{Create a Class Definition}
\description{
Constructs an object of class \code{\linkS4class{classRepresentation}}
to describe a particular class. Mostly a utility function, but you can
call it to create a class definition without assigning it, as
\code{\link{setClass}} would do.
}
\usage{
makeClassRepresentation(name, slots=list(), superClasses=character(),
prototype=NULL, package, validity, access,
version, sealed, virtual=NA, where)
}
\arguments{
\item{name}{character string name for the class}
\item{slots}{named list of slot classes as would be supplied to
\code{setClass}, but \emph{without} the unnamed arguments for
superClasses if any.}
\item{superClasses}{what classes does this class extend}
\item{prototype}{an object providing the default data for the class,
e.g, the result of a call to \code{\link{prototype}}.}
\item{package}{The character string name for the package in which
the class will be stored; see \code{\link{getPackageName}}.}
\item{validity}{Optional validity method. See
\code{\link{validObject}}, and the discussion of validity methods in
the reference.}
\item{access}{Access information. Not currently used.}
\item{version}{Optional version key for version control. Currently
generated, but not used.}
\item{sealed}{Is the class sealed? See \code{\link{setClass}}.}
\item{virtual}{Is this known to be a virtual class?}
\item{where}{The environment from which to look for class
definitions needed (e.g., for slots or superclasses). See the
discussion of this argument under \link{GenericFunctions}.}
}
\references{
Chambers, John M. (2008)
\emph{Software for Data Analysis: Programming with R}
Springer. (For the R version.)
Chambers, John M. (1998)
\emph{Programming with Data}
Springer (For the original S4 version.)
}
\seealso{
\code{\link{setClass}}
}
\keyword{programming}
\keyword{classes}
| 2,197 | gpl-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | junwucs/h2o-3 | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
9bfc705d852b828e848607138889b09558660633 | WelkinGuan/r-source | src/library/methods/man/setSClass.Rd | % File src/library/methods/man/setSClass.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{makeClassRepresentation}
\alias{makeClassRepresentation}
\title{Create a Class Definition}
\description{
Constructs an object of class \code{\linkS4class{classRepresentation}}
to describe a particular class. Mostly a utility function, but you can
call it to create a class definition without assigning it, as
\code{\link{setClass}} would do.
}
\usage{
makeClassRepresentation(name, slots=list(), superClasses=character(),
prototype=NULL, package, validity, access,
version, sealed, virtual=NA, where)
}
\arguments{
\item{name}{character string name for the class}
\item{slots}{named list of slot classes as would be supplied to
\code{setClass}, but \emph{without} the unnamed arguments for
superClasses if any.}
\item{superClasses}{what classes does this class extend}
\item{prototype}{an object providing the default data for the class,
e.g, the result of a call to \code{\link{prototype}}.}
\item{package}{The character string name for the package in which
the class will be stored; see \code{\link{getPackageName}}.}
\item{validity}{Optional validity method. See
\code{\link{validObject}}, and the discussion of validity methods in
the reference.}
\item{access}{Access information. Not currently used.}
\item{version}{Optional version key for version control. Currently
generated, but not used.}
\item{sealed}{Is the class sealed? See \code{\link{setClass}}.}
\item{virtual}{Is this known to be a virtual class?}
\item{where}{The environment from which to look for class
definitions needed (e.g., for slots or superclasses). See the
discussion of this argument under \link{GenericFunctions}.}
}
\references{
Chambers, John M. (2008)
\emph{Software for Data Analysis: Programming with R}
Springer. (For the R version.)
Chambers, John M. (1998)
\emph{Programming with Data}
Springer (For the original S4 version.)
}
\seealso{
\code{\link{setClass}}
}
\keyword{programming}
\keyword{classes}
| 2,197 | gpl-2.0 |
9bfc705d852b828e848607138889b09558660633 | mathematicalcoffee/r-source | src/library/methods/man/setSClass.Rd | % File src/library/methods/man/setSClass.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{makeClassRepresentation}
\alias{makeClassRepresentation}
\title{Create a Class Definition}
\description{
Constructs an object of class \code{\linkS4class{classRepresentation}}
to describe a particular class. Mostly a utility function, but you can
call it to create a class definition without assigning it, as
\code{\link{setClass}} would do.
}
\usage{
makeClassRepresentation(name, slots=list(), superClasses=character(),
prototype=NULL, package, validity, access,
version, sealed, virtual=NA, where)
}
\arguments{
\item{name}{character string name for the class}
\item{slots}{named list of slot classes as would be supplied to
\code{setClass}, but \emph{without} the unnamed arguments for
superClasses if any.}
\item{superClasses}{what classes does this class extend}
\item{prototype}{an object providing the default data for the class,
e.g, the result of a call to \code{\link{prototype}}.}
\item{package}{The character string name for the package in which
the class will be stored; see \code{\link{getPackageName}}.}
\item{validity}{Optional validity method. See
\code{\link{validObject}}, and the discussion of validity methods in
the reference.}
\item{access}{Access information. Not currently used.}
\item{version}{Optional version key for version control. Currently
generated, but not used.}
\item{sealed}{Is the class sealed? See \code{\link{setClass}}.}
\item{virtual}{Is this known to be a virtual class?}
\item{where}{The environment from which to look for class
definitions needed (e.g., for slots or superclasses). See the
discussion of this argument under \link{GenericFunctions}.}
}
\references{
Chambers, John M. (2008)
\emph{Software for Data Analysis: Programming with R}
Springer. (For the R version.)
Chambers, John M. (1998)
\emph{Programming with Data}
Springer (For the original S4 version.)
}
\seealso{
\code{\link{setClass}}
}
\keyword{programming}
\keyword{classes}
| 2,197 | gpl-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | tarasane/h2o-3 | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | ChristosChristofidis/h2o-3 | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | brightchen/h2o-3 | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | bikash/h2o-dev | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | rowhit/h2o-2 | R/h2o-package/man/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | weaver-viii/h2o-3 | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | woobe/h2o | R/h2o-package/man/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | elkingtonmcb/h2o-2 | R/h2o-package/man/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | h2oai/h2o-2 | R/h2o-package/man/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | calvingit21/h2o-2 | R/h2o-package/man/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | bospetersen/h2o-3 | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
395cafdd529a0c2f8a97320166c4443c4dbfae23 | MaximeWack/R2b2 | man/list_users.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/users.R
\name{list_users}
\alias{list_users}
\title{List users}
\usage{
list_users(host = "", admin = "", pass = "")
}
\arguments{
\item{host}{The host to connect to}
\item{admin}{The admin account for the PostgreSQL database}
\item{pass}{The password for the database admin}
}
\description{
Delete i2b2 users from the instance
}
| 410 | gpl-3.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | datachand/h2o-3 | h2o-r/man-old/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
9bfc705d852b828e848607138889b09558660633 | andy-thomason/r-source | src/library/methods/man/setSClass.Rd | % File src/library/methods/man/setSClass.Rd
% Part of the R package, https://www.R-project.org
% Copyright 1995-2007 R Core Team
% Distributed under GPL 2 or later
\name{makeClassRepresentation}
\alias{makeClassRepresentation}
\title{Create a Class Definition}
\description{
Constructs an object of class \code{\linkS4class{classRepresentation}}
to describe a particular class. Mostly a utility function, but you can
call it to create a class definition without assigning it, as
\code{\link{setClass}} would do.
}
\usage{
makeClassRepresentation(name, slots=list(), superClasses=character(),
prototype=NULL, package, validity, access,
version, sealed, virtual=NA, where)
}
\arguments{
\item{name}{character string name for the class}
\item{slots}{named list of slot classes as would be supplied to
\code{setClass}, but \emph{without} the unnamed arguments for
superClasses if any.}
\item{superClasses}{what classes does this class extend}
\item{prototype}{an object providing the default data for the class,
e.g, the result of a call to \code{\link{prototype}}.}
\item{package}{The character string name for the package in which
the class will be stored; see \code{\link{getPackageName}}.}
\item{validity}{Optional validity method. See
\code{\link{validObject}}, and the discussion of validity methods in
the reference.}
\item{access}{Access information. Not currently used.}
\item{version}{Optional version key for version control. Currently
generated, but not used.}
\item{sealed}{Is the class sealed? See \code{\link{setClass}}.}
\item{virtual}{Is this known to be a virtual class?}
\item{where}{The environment from which to look for class
definitions needed (e.g., for slots or superclasses). See the
discussion of this argument under \link{GenericFunctions}.}
}
\references{
Chambers, John M. (2008)
\emph{Software for Data Analysis: Programming with R}
Springer. (For the R version.)
Chambers, John M. (1998)
\emph{Programming with Data}
Springer (For the original S4 version.)
}
\seealso{
\code{\link{setClass}}
}
\keyword{programming}
\keyword{classes}
| 2,197 | gpl-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | 111t8e/h2o-2 | R/h2o-package/man/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
ea85607a2cd1c1b04ab1bc832a8aad4cca0d3f6a | vbelakov/h2o | R/h2o-package/man/H2ODRFModel-class.Rd | \name{H2ODRFModel-class}
\Rdversion{1.1}
\docType{class}
\alias{H2ODRFModel-class}
\alias{show,H2ODRFModel-method}
\title{Class \code{"H2ODRFModel"}}
\description{
A class for representing random forest ensembles.
}
\section{Objects from the Class}{
Objects can be created by calls of the form \code{new("H2ODRFModel", ...)}.
%% ~~ describe objects here ~~
}
\section{Slots}{
\describe{
\item{\code{key}:}{Object of class \code{"character"}, representing the unique hex key that identifies the model.}
\item{\code{data}:}{Object of class \code{"H2OParsedData"}, which is the input data used to build the model.}
\item{\code{model}:}{Object of class \code{"list"} containing the following elements:
\itemize{
\item{\code{type}: The type of the tree, which at this point must be classification.}
\item{\code{ntree}: Number of trees grown.}
\item{\code{oob_err}: Out of bag error rate.}
\item{\code{forest}: A matrix giving the minimum, mean, and maximum of the tree depth and number of leaves.}
\item{\code{confusion}: Confusion matrix of the prediction.}
}
}
\item{\code{valid}:}{Object of class \code{"H2OParsedData"}, which is the data used for validating the model.}
\item{\code{xval}:}{List of objects of class \code{"H2ODRFModel"}, representing the n-fold cross-validation models.}
}
}
\section{Extends}{
Class \code{"\linkS4class{H2OModel}"}, directly.
}
\section{Methods}{
\describe{
\item{show}{\code{signature(object = "H2ODRFModel")}: ... }
}
}
\seealso{
%% ~~objects to See Also as \code{\link{~~fun~~}}, ~~~
%% ~~or \code{\linkS4class{CLASSNAME}} for links to other classes ~~~
\code{\link{h2o.randomForest}}
}
\examples{
showClass("H2ODRFModel")
}
\keyword{classes}
| 1,775 | apache-2.0 |
0ff2aa4404c70a8689690a508f09dc3674f93ede | kou/arrow | r/man/to_duckdb.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/duckdb.R
\name{to_duckdb}
\alias{to_duckdb}
\title{Create a (virtual) DuckDB table from an Arrow object}
\usage{
to_duckdb(
.data,
con = arrow_duck_connection(),
table_name = unique_arrow_tablename(),
auto_disconnect = TRUE
)
}
\arguments{
\item{.data}{the Arrow object (e.g. Dataset, Table) to use for the DuckDB table}
\item{con}{a DuckDB connection to use (default will create one and store it
in \code{options("arrow_duck_con")})}
\item{table_name}{a name to use in DuckDB for this object. The default is a
unique string \code{"arrow_"} followed by numbers.}
\item{auto_disconnect}{should the table be automatically cleaned up when the
resulting object is removed (and garbage collected)? Default: \code{TRUE}}
}
\value{
A \code{tbl} of the new table in DuckDB
}
\description{
This will do the necessary configuration to create a (virtual) table in DuckDB
that is backed by the Arrow object given. No data is copied or modified until
\code{collect()} or \code{compute()} are called or a query is run against the table.
}
\details{
The result is a dbplyr-compatible object that can be used in d(b)plyr pipelines.
If \code{auto_disconnect = TRUE}, the DuckDB table that is created will be configured
to be unregistered when the \code{tbl} object is garbage collected. This is helpful
if you don't want to have extra table objects in DuckDB after you've finished
using them.
}
\examples{
\dontshow{if (getFromNamespace("run_duckdb_examples", "arrow")()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
library(dplyr)
ds <- InMemoryDataset$create(mtcars)
ds \%>\%
filter(mpg < 30) \%>\%
group_by(cyl) \%>\%
to_duckdb() \%>\%
slice_min(disp)
\dontshow{\}) # examplesIf}
}
| 1,795 | apache-2.0 |
0ff2aa4404c70a8689690a508f09dc3674f93ede | apache/arrow | r/man/to_duckdb.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/duckdb.R
\name{to_duckdb}
\alias{to_duckdb}
\title{Create a (virtual) DuckDB table from an Arrow object}
\usage{
to_duckdb(
.data,
con = arrow_duck_connection(),
table_name = unique_arrow_tablename(),
auto_disconnect = TRUE
)
}
\arguments{
\item{.data}{the Arrow object (e.g. Dataset, Table) to use for the DuckDB table}
\item{con}{a DuckDB connection to use (default will create one and store it
in \code{options("arrow_duck_con")})}
\item{table_name}{a name to use in DuckDB for this object. The default is a
unique string \code{"arrow_"} followed by numbers.}
\item{auto_disconnect}{should the table be automatically cleaned up when the
resulting object is removed (and garbage collected)? Default: \code{TRUE}}
}
\value{
A \code{tbl} of the new table in DuckDB
}
\description{
This will do the necessary configuration to create a (virtual) table in DuckDB
that is backed by the Arrow object given. No data is copied or modified until
\code{collect()} or \code{compute()} are called or a query is run against the table.
}
\details{
The result is a dbplyr-compatible object that can be used in d(b)plyr pipelines.
If \code{auto_disconnect = TRUE}, the DuckDB table that is created will be configured
to be unregistered when the \code{tbl} object is garbage collected. This is helpful
if you don't want to have extra table objects in DuckDB after you've finished
using them.
}
\examples{
\dontshow{if (getFromNamespace("run_duckdb_examples", "arrow")()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
library(dplyr)
ds <- InMemoryDataset$create(mtcars)
ds \%>\%
filter(mpg < 30) \%>\%
group_by(cyl) \%>\%
to_duckdb() \%>\%
slice_min(disp)
\dontshow{\}) # examplesIf}
}
| 1,795 | apache-2.0 |
c4df66af27a4fa34cba1adef951aa3df3c447418 | Project-R-Adamant/radamant | man/3dptelem.Rd | \name{3dptelem}
\alias{lines3d}
\alias{points3d}
\alias{rect3d}
\alias{text3d}
\title{ 3D Plot Elements}
\description{Add elements to 3D Plot }
\usage{
lines3d(x, y, z, pmat = getProjectionMatrix(), ...)
points3d(x, y, z, pmat = getProjectionMatrix(), ...)
rect3d(xrange, yrange, z, pmat = getProjectionMatrix(), ...)
text3d(x, y, z, pmat = getProjectionMatrix(), ...)
}
\arguments{
\item{x}{ X axis}
\item{y}{ Y axis}
\item{z}{ Z axis}
\item{pmat}{ pamt}
\item{...}{ Further arguments to or from other methods}
\item{xrange}{ xrange}
\item{yrange}{ yrange}
}
\author{ RAdamant Development Team \email{[email protected]}}
| 632 | gpl-2.0 |
c8a62d572b78dbd0be4184a7901f8ee7c45333b4 | personlin/GMPEhaz | man/BSSA14.tw.E02.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/BSSA14_tw_E02.R
\name{BSSA14.tw.E02}
\alias{BSSA14.tw.E02}
\title{GMPE function for Boore et al.(2014) NGA-West2 model}
\usage{
BSSA14.tw.E02(Mag, Rjb, Prd, Vs30, ftype = 0, Z1.0, regionflag = 0,
basinflag = 0)
}
\arguments{
\item{Mag}{Earthquake momnet magnitude, Numeric.}
\item{Rjb}{Joyner and Boore distance(km), Numeric.}
\item{Prd}{Period of spectral acceleration.}
\item{Vs30}{Vs30(m/s).}
\item{ftype}{style of faulting.}
\item{Z1.0}{the depth to the shear-wave velocity horizon of 1.0(km/s).}
\item{regionflag}{Regional attenuation flag, 0 = Global, 1 = China-Turkey, 2 = Italy-Japan.}
\item{basinflag}{Basin Adjustments.}
}
\value{
A list will be return, including mag, Rjb, specT, period, lnY, sigma, iflag, Vs30, ftype, pga4nl,
Z10, regionflag, basinflag, phi, tau.
}
\description{
\code{BSSA14.tw.E02} returns the ground-motion prediction with it sigma of Boore et al.(2014) GMPE
adjusted to Taiwan.
}
\details{
Boore, D. M., J. P. Stewart, E. Seyhan, and G. M. Atkinson (2014), NGA-west2 equations for predicting
PGA, PGV, and 5% damped PSA for shallow crustal earthquakes, Earthquake Spectra, 30(3), 1057-1085.
\url{http://dx.doi.org/10.1193/070113EQS184M}
}
\examples{
BSSA14.tw.E02(6, 20, 0, 760, 0, 0.5, 0, 0)
BSSA14.tw.E02(7, 20, 0, 760, 0, 0.5, 0, 0)
}
| 1,360 | gpl-3.0 |
0ff2aa4404c70a8689690a508f09dc3674f93ede | icexelloss/arrow | r/man/to_duckdb.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/duckdb.R
\name{to_duckdb}
\alias{to_duckdb}
\title{Create a (virtual) DuckDB table from an Arrow object}
\usage{
to_duckdb(
.data,
con = arrow_duck_connection(),
table_name = unique_arrow_tablename(),
auto_disconnect = TRUE
)
}
\arguments{
\item{.data}{the Arrow object (e.g. Dataset, Table) to use for the DuckDB table}
\item{con}{a DuckDB connection to use (default will create one and store it
in \code{options("arrow_duck_con")})}
\item{table_name}{a name to use in DuckDB for this object. The default is a
unique string \code{"arrow_"} followed by numbers.}
\item{auto_disconnect}{should the table be automatically cleaned up when the
resulting object is removed (and garbage collected)? Default: \code{TRUE}}
}
\value{
A \code{tbl} of the new table in DuckDB
}
\description{
This will do the necessary configuration to create a (virtual) table in DuckDB
that is backed by the Arrow object given. No data is copied or modified until
\code{collect()} or \code{compute()} are called or a query is run against the table.
}
\details{
The result is a dbplyr-compatible object that can be used in d(b)plyr pipelines.
If \code{auto_disconnect = TRUE}, the DuckDB table that is created will be configured
to be unregistered when the \code{tbl} object is garbage collected. This is helpful
if you don't want to have extra table objects in DuckDB after you've finished
using them.
}
\examples{
\dontshow{if (getFromNamespace("run_duckdb_examples", "arrow")()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
library(dplyr)
ds <- InMemoryDataset$create(mtcars)
ds \%>\%
filter(mpg < 30) \%>\%
group_by(cyl) \%>\%
to_duckdb() \%>\%
slice_min(disp)
\dontshow{\}) # examplesIf}
}
| 1,795 | apache-2.0 |
c4df66af27a4fa34cba1adef951aa3df3c447418 | hjl2014/radamant | man/3dptelem.Rd | \name{3dptelem}
\alias{lines3d}
\alias{points3d}
\alias{rect3d}
\alias{text3d}
\title{ 3D Plot Elements}
\description{Add elements to 3D Plot }
\usage{
lines3d(x, y, z, pmat = getProjectionMatrix(), ...)
points3d(x, y, z, pmat = getProjectionMatrix(), ...)
rect3d(xrange, yrange, z, pmat = getProjectionMatrix(), ...)
text3d(x, y, z, pmat = getProjectionMatrix(), ...)
}
\arguments{
\item{x}{ X axis}
\item{y}{ Y axis}
\item{z}{ Z axis}
\item{pmat}{ pamt}
\item{...}{ Further arguments to or from other methods}
\item{xrange}{ xrange}
\item{yrange}{ yrange}
}
\author{ RAdamant Development Team \email{[email protected]}}
| 632 | gpl-2.0 |
19f46d04da2f5808ae50e09be2fa357e17709ee6 | FeiYeYe/syberiaStages | man/fetch_adapter.Rd | % Generated by roxygen2 (4.0.2.9000): do not edit by hand
% Please edit documentation in R/adapter.r
\name{fetch_adapter}
\alias{fetch_adapter}
\title{Fetch a syberia IO adapter.}
\usage{
fetch_adapter(keyword)
}
\arguments{
\item{keyword}{character. The keyword for the adapter (e.g., 'file', 's3', etc.)}
}
\value{
an \code{adapter} object (defined in this package, syberiaStages)
}
\description{
IO adapters are (reference class) objects that have a \code{read}
and \code{write} method. By wrapping things in an adapter, you do not have to
worry about whether to use, e.g., \code{read.csv} versus \code{s3read}
or \code{write.csv} versus \code{s3store}. If you are familiar with
the tundra package, think of adapters as like tundra containers for
importing and exporting data.
}
\details{
For example, we can do: \code{fetch_adapter('file')$write(iris, '/tmp/iris.csv')}
and the contents of the built-in \code{iris} data set will be stored
in the file \code{"/tmp/iris.csv"}.
}
| 982 | mit |
4fe25686a676d6147daa800009593c34689dc59e | jrodrigop/Rfoursquare | man/venues.photos.Rd | % Generated by roxygen2 (4.0.2): do not edit by hand
\name{venues.photos}
\alias{venues.photos}
\title{Photos from a Venue}
\usage{
venues.photos(VENUE_ID = NULL, group = NULL, limit = NULL,
offset = NULL, m = "foursquare")
}
\arguments{
\item{VENUE_ID}{required The venue you want photos for.}
\item{group}{If not specified, public venue photos are
returned ordered by relevance. Pass venue for public venue
photos, ordered by recency. Pass checkin for venue photos
from friends (including non-public photos from recent
checkins), ordered by recency. See our documentation on
photos for information on how to handle the response and
construct actual photo URLs.}
\item{limit}{Number of results to return, up to 200.}
\item{offset}{Used to page through results.}
\item{m}{Accepts values of "foursquare"}
}
\value{
photos A count and items of photo.
}
\description{
Returns photos for a venue.
}
\details{
Returns photos for a venue.
}
\examples{
venues.photos(VENUE_ID="XXX123YYYY", group="checkin",
limit="100", offset="100")
}
| 1,037 | gpl-2.0 |
4caef62398e593b387d40b3d448e12af1c4fe203 | guanlongtianzi/shinyOfGBM | R-package/man/xgb.load.Rd | % Generated by roxygen2 (4.1.0): do not edit by hand
% Please edit documentation in R/xgb.load.R
\name{xgb.load}
\alias{xgb.load}
\title{Load xgboost model from binary file}
\usage{
xgb.load(modelfile)
}
\arguments{
\item{modelfile}{the name of the binary file.}
}
\description{
Load xgboost model from the binary model file
}
\examples{
data(agaricus.train, package='xgboost')
data(agaricus.test, package='xgboost')
train <- agaricus.train
test <- agaricus.test
bst <- xgboost(data = train$data, label = train$label, max.depth = 2,
eta = 1, nthread = 2, nround = 2,objective = "binary:logistic")
xgb.save(bst, 'xgb.model')
bst <- xgb.load('xgb.model')
pred <- predict(bst, test$data)
}
| 703 | gpl-3.0 |
60e1da5640078886cc68b57c6cde11cdae90bc65 | Project-R-Adamant/radamant | man/invlogit.Rd | \name{invlogit}
\alias{inv.logit}
\title{Inverse Logit transformation}
\description{Inverse Logit transformation}
\usage{inv.logit(y) }
\arguments{
\item{y}{ y}}
\author{RAdamant Development Team \email{[email protected]}}
\note{TO BE COMPLETED}
| 249 | gpl-2.0 |
60e1da5640078886cc68b57c6cde11cdae90bc65 | hjl2014/radamant | man/invlogit.Rd | \name{invlogit}
\alias{inv.logit}
\title{Inverse Logit transformation}
\description{Inverse Logit transformation}
\usage{inv.logit(y) }
\arguments{
\item{y}{ y}}
\author{RAdamant Development Team \email{[email protected]}}
\note{TO BE COMPLETED}
| 249 | gpl-2.0 |
3e610eeb390672a72c08f83732487e97363b9947 | hendrikTpl/darch | man/setVisibleBiases-methods.Rd | % Generated by roxygen2 (4.1.1): do not edit by hand
% Please edit documentation in R/rbm.Setter.R
\docType{methods}
\name{setVisibleBiases<-}
\alias{setVisibleBiases}
\alias{setVisibleBiases<-}
\alias{setVisibleBiases<-,RBM-method}
\title{Sets the biases of the visible units for the \code{\link{RBM}} object}
\usage{
setVisibleBiases(rbm) <- value
\S4method{setVisibleBiases}{RBM}(rbm) <- value
}
\arguments{
\item{rbm}{A instance of the class \code{\link{RBM}}.}
\item{value}{The biases of the visible units for the \code{\link{RBM}} object.}
}
\description{
Sets the biases of the visible units for the \code{\link{RBM}} object
}
\seealso{
\code{\link{RBM}}
}
| 667 | gpl-3.0 |
f5547885276606205a68bd04c84748c3dee0238d | oscardelama/imgnoiser | man/vvm-cash-digest.Rd | % Generated by roxygen2 (4.1.0): do not edit by hand
% Please edit documentation in R/vvm-class.r
\name{vvm$digest}
\alias{vvm$digest}
\title{Process the raw image samples.}
\arguments{
\item{file.name.from}{}
\item{file.name.to}{The \code{file.name.from} and \code{file.name.to} are the
alphabetical range of the desired files from the folder given in
\code{file.path}. These names should not include the file name
extension, which is specified with \code{file.name.ext}.}
\item{file.path}{The file path where the raw image file samples are located.}
\item{file.name.ext}{The file name extension of the raw image file samples.
It can be 'fit', 'fits' or 'pgm'. This file name extension may start or not
with a period as in '.fit' or fit'.
The supported values for the \code{img.file.name.ext} are '.fit' or '.fits'
for the \href{http://fits.gsfc.nasa.gov/}{'FITS'} format or '.pgm' for the
\href{http://netpbm.sourceforge.net/doc/pgm.html}{'PGM'} format.}
\item{min.raw}{}
\item{max.raw}{These are the the expected pixel values range. If more than
the 2% of pixel values in an image channel sample is outside this range,
the channel is discarded.
Each parameter can be a single value or a vector of four values. For the
single value case, the same value is used as limit for the four channels,
otherwise there must be four values, one per channel and in the image sample
channels order.}
}
\value{
A \code{invisible} instance of the calling object.
}
\description{
Read raw image samples and compute variance and covariance statistics for
each channnel.
}
\details{
The calling arguments describe the list of raw image files that will be
processed. The image samples file names are expected to have the following
pattern:
\emph{\code{file.path}/\code{<img.file.base>}.\code{<file.name.ext>}}
Where \code{<img.file.base>} is alfabetically between the
\code{file.name.from} and \code{file.name.to} arguments.
In other words, the folder given in \code{file.path} is scanned looking
for files with base name between (and including) \code{file.name.from} and
\code{file.name.to}, having all of them the extension \code{file.name.ext}.
If your sample file names do not follow this pattern, you can specify them as
a character vector as argument for the \code{<file.name.from>} parameter.
The \code{\link{select.file.range}} may help you to get a baseline selection with
the files you want to get processed by this function.
}
\section{Usage}{
\preformatted{
vvm$digest(
file.name.from = stop("The 'file.name.from' argument is missing."),
file.name.to = stop("The 'file.name.to' argument is missing."),
file.path = './',
file.name.ext = '.pgm'
min.raw = 0
max.raw = Inf
)
}
}
\examples{
\dontrun{
# Create a new vvm instance
my.vvm <- vvm$new(has.RGGB.pattern=TRUE)
img.path <- 'D:/Noise-Study/Nikon-D7000/ISO-100'
my.vvm$digest('_ODL5695', '_ODL5767', '.pgm', img.path)
}
}
\seealso{
See the section \emph{"Input data for the *vvm* Procedure"} in the
\emph{"Introduction to the *vvm* technique"} vignette,
\code{\link{vvm}}.
}
| 3,131 | gpl-2.0 |
acd42f31aef00671fbdc7ce39b43b21775aee843 | woobe/h2o | R/h2o-package/man/h2o.addFunction.Rd | \name{h2o.addFunction}
\alias{h2o.addFunction}
%- Also NEED an '\alias' for EACH other topic documented here.
\title{
Adds an R function to H2O
}
\description{
Add a function defined in R to the H2O server, so it is recognized for future operations on H2O. This method is necessary because R functions are not automatically pushed across via the REST API to H2O.
}
\usage{
h2o.addFunction(object, fun, name)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{object}{
An \code{\linkS4class{H2OClient}} object containing the IP address and port of the server running H2O.
}
\item{fun}{
A function in R. Currently, only a subset of the R syntax is recognizable by H2O, and functions that fall outside this set will be rejected. Values referred to by \code{fun} must be defined within H2O, e.g. a H2O dataset must be referred to by its key name, not its H2OParsedData R variable name.
}
\item{name}{
(Optional) A character string giving the name that the function should be saved under in H2O. If missing, defaults to the name that the function is saved under in R.
}
}
\details{
%% ~~ If necessary, more details than the description above ~~
This method is intended to be used in conjunction with \code{\link{h2o.ddply}}. The user must explicitly add the function he or she wishes to apply to H2O. Otherwise, the server will not recognize a function reference that only exists in R.
}
\seealso{
%% ~~objects to See Also as \code{\link{help}}, ~~~
\code{\link{h2o.ddply}}
}
\examples{
library(h2o)
localH2O = h2o.init(ip = "localhost", port = 54321, startH2O = TRUE)
h2o.addFunction(localH2O, function(x) { 2*x + 5 }, "simpleFun")
}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
\keyword{ ~kwd1 }
\keyword{ ~kwd2 }% __ONLY ONE__ keyword per line
| 1,823 | apache-2.0 |
1f8ce757c50b43bfc10e0d20f24aa8c5c810a521 | claudia-codeco/AlertTools | man/plot_alertaRio.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/alert_functions.R
\name{plot_alertaRio}
\alias{plot_alertaRio}
\title{Plot the time series of alerts for each APS. Specific for the Rio de Janeiro alert model.}
\usage{
plot_alertaRio(
ale,
aps,
var = "casos",
cores = c("#0D6B0D", "#C8D20F", "orange", "red"),
ini = 201001,
fim = 202001,
ylab = var,
yrange,
salvar = FALSE,
nome.fig = "grafico",
datasource = con
)
}
\arguments{
\item{ale}{object created by alertaRio()}
\item{aps}{aps to be plotted. If missing, figures will be created for all aps (health districts)}
\item{var}{variable to be plotted, usually "cases", or "inc".}
\item{cores}{colors corresponding to the levels 1, 2, 3, 4.}
\item{ini}{first epidemiological week. If not stated, use the first one available}
\item{fim}{last epidemiological week. If not stated, use the last one available}
\item{ylab}{y axis label}
\item{yrange}{y axis range}
\item{salvar}{TRUE to save the figure (default is FALSE)}
\item{nome.fig}{figure name (default is "grafico")}
}
\value{
a plot
}
\description{
Function to plot the output of alertaRio().
}
\examples{
# Parameters for the model
alerio2 <- alertaRio(naps = 0:9, se=201804, delaymethod="fixedprob", cid10 = "A90")
plot_alertaRio(alerio2, var = "inc")
}
| 1,320 | gpl-3.0 |
83713e6d6bb427315256f3cb85405960bd1f4291 | pmur002/wmctrl | man/addWindowState.Rd | \name{addWindowState}
\alias{addWindowState}
\alias{removeWindowState}
\alias{toggleWindowState}
\title{
Modify window properties.
}
\description{
Add, remove, or toggle a window property.
}
\usage{
addWindowState(windowID, state)
removeWindowState(windowID, state)
toggleWindowState(windowID, state)
}
\arguments{
\item{windowID}{
A unique window identifier (see \code{\link{getWindowID}}).
}
\item{state}{
The name of the property to modify. One of:
modal, sticky, maximized_vert, maximized_horz,
shaded, skip_taskbar, skip_pager, hidden, fullscreen, above, and
below.
}
}
\references{
\url{http://tripie.sweb.cz/utils/wmctrl/}
}
\author{
Paul Murrell
}
\keyword{ utilities }
| 714 | gpl-3.0 |
acd42f31aef00671fbdc7ce39b43b21775aee843 | janezhango/BigDataMachineLearning | R/h2o-package/man/h2o.addFunction.Rd | \name{h2o.addFunction}
\alias{h2o.addFunction}
%- Also NEED an '\alias' for EACH other topic documented here.
\title{
Adds an R function to H2O
}
\description{
Add a function defined in R to the H2O server, so it is recognized for future operations on H2O. This method is necessary because R functions are not automatically pushed across via the REST API to H2O.
}
\usage{
h2o.addFunction(object, fun, name)
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{object}{
An \code{\linkS4class{H2OClient}} object containing the IP address and port of the server running H2O.
}
\item{fun}{
A function in R. Currently, only a subset of the R syntax is recognizable by H2O, and functions that fall outside this set will be rejected. Values referred to by \code{fun} must be defined within H2O, e.g. a H2O dataset must be referred to by its key name, not its H2OParsedData R variable name.
}
\item{name}{
(Optional) A character string giving the name that the function should be saved under in H2O. If missing, defaults to the name that the function is saved under in R.
}
}
\details{
%% ~~ If necessary, more details than the description above ~~
This method is intended to be used in conjunction with \code{\link{h2o.ddply}}. The user must explicitly add the function he or she wishes to apply to H2O. Otherwise, the server will not recognize a function reference that only exists in R.
}
\seealso{
%% ~~objects to See Also as \code{\link{help}}, ~~~
\code{\link{h2o.ddply}}
}
\examples{
library(h2o)
localH2O = h2o.init(ip = "localhost", port = 54321, startH2O = TRUE)
h2o.addFunction(localH2O, function(x) { 2*x + 5 }, "simpleFun")
}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
\keyword{ ~kwd1 }
\keyword{ ~kwd2 }% __ONLY ONE__ keyword per line
| 1,823 | apache-2.0 |
55c7a470d516ea2133947822a733dd1933e521bd | RandiIP/blm | man/print.blm.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/ModelMethods.R
\name{print.blm}
\alias{print.blm}
\title{Print a blm object}
\usage{
\method{print}{blm}(x, ...)
}
\arguments{
\item{x}{the blm object}
\item{...}{any extra parameters}
}
\value{
a print with the call and coefficients
}
\description{
This function prints the most general information from the object
}
| 398 | gpl-2.0 |
0a10b8c9548f2ea182a65da636b8259ab1032e70 | thongsav-usgs/repgen | man/getCorrectionsPlotConfig.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/uvhydrograph-render.R
\name{getCorrectionsPlotConfig}
\alias{getCorrectionsPlotConfig}
\title{Get Corrections Plot Config}
\usage{
getCorrectionsPlotConfig(corrections, plotStartDate, plotEndDate, label, limits)
}
\arguments{
\item{corrections}{list of data objects relavant to plotting corrections data}
\item{plotStartDate}{start date of this plot}
\item{plotEndDate}{end date of this plot}
\item{label}{label of that these corrections are associated with}
\item{limits}{list of lims for all of the data which will be on here}
}
\value{
named list of gsplot calls. The name is the plotting call to make, and it points to a list of config params for that call
}
\description{
Given corrections, some information about the plot to build, will return a named list of gsplot elements to call
}
| 874 | cc0-1.0 |
718758f6d989974f160b9f3e419f85cff632fdc5 | droglenc/fishWiDNR | man/read.FMDB.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/read.FMDB.R
\name{read.FMDB}
\alias{read.FMDB}
\title{Read CSV of WiDNR Fish Management Data.}
\usage{
read.FMDB(file, addSpecies = TRUE, addMonth = TRUE, expandCounts = FALSE,
whichLengths = c("in", "mm"), lprec = 0.1, na.strings = c("-", "NA",
""), verbose = TRUE)
}
\arguments{
\item{file}{The name of the external CSV file from the WiDNR Fisheries Management Database.}
\item{addSpecies}{A logical that indicates whether a new variable of species names where only the first word is capitalized should be added to the returned data.frame.}
\item{addMonth}{A logical that indicates whether a new variable of month of capture should be added to the returned data.frame.}
\item{expandCounts}{A logical that indicates whether counts of fish of the same length should be expanded to be individual fish in the returned data.frame or not. See \code{\link[FSA]{expandCounts}} in \pkg{FSA}.}
\item{whichLengths}{A character string that indicates whether the expanded lengths, when \code{expandCounts=TRUE}, use the English (inches; \code{whichLengths="in"}) or metric (mm; \code{whichLengths="mm"}) units variable.}
\item{lprec}{A single numeric that controls the precision to which the random lengths are recorded. See details in \code{\link[FSA]{expandCounts}} in \pkg{FSA}.}
\item{na.strings}{A vector of character strings that indicate what type of characters should be considered missing when reading the CSV file. Likely does not need to be changed.}
\item{verbose}{A logical that indicates whether progress messages should be printed or not.}
\item{\dots}{Not yet implemented.}
}
\value{
A data.frame.
}
\description{
Reads a CSV of WiDNR Fish Management Data, sets variable classes, and optionally adds some variables and expands fish counts.
}
\details{
This function is used to read a CSV created directly from the WiDNR Fish Management Database and appropriately set the class type (e.g., integer, factor, etc.) for the variables. Optionally, the user may add the month the fish was collected and change the species names so that only the first letters are capitalized (so as to work more easily with other functions). Furthermore, the user may optionally choose to expand the counts of fish of the same lengths (often times no length was recorded, fish were just counted).
}
\examples{
## Get external file (as part of the package)
ftmp <- system.file("extdata", "FMDB_ex.csv",package="fishWiDNR")
## Read file without expanding counts
df1 <- read.FMDB(ftmp)
str(df1)
## Read file with expanding counts
df2 <- read.FMDB(ftmp,expandCounts=TRUE)
str(df2)
}
\author{
Derek H. Ogle, \email{[email protected]}
}
\seealso{
\code{\link{setFMDBClasses}}; \code{\link[FSA]{expandCounts}} in \pkg{FSA}.
}
\keyword{manip}
| 2,818 | gpl-2.0 |
0a10b8c9548f2ea182a65da636b8259ab1032e70 | lindsaycarr/repgen | man/getCorrectionsPlotConfig.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/uvhydrograph-render.R
\name{getCorrectionsPlotConfig}
\alias{getCorrectionsPlotConfig}
\title{Get Corrections Plot Config}
\usage{
getCorrectionsPlotConfig(corrections, plotStartDate, plotEndDate, label, limits)
}
\arguments{
\item{corrections}{list of data objects relavant to plotting corrections data}
\item{plotStartDate}{start date of this plot}
\item{plotEndDate}{end date of this plot}
\item{label}{label of that these corrections are associated with}
\item{limits}{list of lims for all of the data which will be on here}
}
\value{
named list of gsplot calls. The name is the plotting call to make, and it points to a list of config params for that call
}
\description{
Given corrections, some information about the plot to build, will return a named list of gsplot elements to call
}
| 874 | cc0-1.0 |
342a46c4eb957868c4cd956ae1e78a126a34dbcf | paulpflug/Rvasp | Rvasp/man/plot.projectedbands.add.Rd | \name{plot.projectedbands.add}
\alias{plot.projectedbands.add}
\title{Adds projected orbitals to existing plot}
\usage{
plot.projectedbands.add(projectedbands,
bands = 1:length(projectedbands$bands),
orbitals = list(1, 2, 3, 4), col = NULL,
col.palette = colorRampPalette(c("red", "blue", "green")),
pch = 15:(14 + length(orbitals)), cex = 0.8,
cex.cutoff = 0.2, legend = "topright", legendcex = 0.8,
energyoffset = NULL, usetransparent = T, ...)
}
\arguments{
\item{projectedbands}{object of class projectedbands}
\item{bands}{limits plotting to specified bands}
\item{orbitals}{list of orbitals to plot. To sum over
orbitals 2 and 3 use \code{list(1,c(2,3),4)}}
\item{col}{colors for orbitals, will be recycled by the
length of orbitals, if not provided, will use col.platte
for generation.}
\item{col.palette}{color palette for orbitals}
\item{legend}{position of legend, \code{NULL} will
supress plotting}
\item{legendcex}{size of legend}
\item{energyoffset}{will be added to energy of all bands}
\item{usetransparent}{determines usage of transparency}
\item{cex.cutoff}{will only be used if usetransparent
equals \code{FALSE}. Prevents plotting of smaller than
cutoff points.}
\item{...}{further plotting parameters}
}
\description{
\code{plot.projectedbands.add} adds projected orbitals to
existing plot.
}
| 1,388 | mit |
6bc33b72bb1c04f08740c1703bf83627714a73ab | tylermorganwall/skpr | man/get_optimality.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/get_optimality.R
\name{get_optimality}
\alias{get_optimality}
\title{Get optimality values}
\usage{
get_optimality(output, optimality = NULL)
}
\arguments{
\item{output}{The output of either gen_design or eval_design/eval_design_mc.}
\item{optimality}{Default `NULL`. Return just the specific optimality requested.}
}
\value{
A dataframe of optimality conditions. `D`, `A`, and `G` are efficiencies (value is out of 100).
`T` is the trace of the information matrix, `E` is the minimum eigenvalue of the information matrix,
`I` is the average prediction variance, and `Alias` is the trace of the alias matrix.
}
\description{
Returns a list of optimality values (or one value in particular).
Note: The choice of contrast will effect the `G` efficiency value, and `gen_design()`
and `eval_design()` by default set different contrasts (`contr.simplex` vs `contr.sum`).
}
\examples{
# We can extract the optimality of a design from either the output of `gen_design()`
# or the output of `eval_design()`
factorialcoffee = expand.grid(cost = c(1, 2),
type = as.factor(c("Kona", "Colombian", "Ethiopian", "Sumatra")),
size = as.factor(c("Short", "Grande", "Venti")))
designcoffee = gen_design(factorialcoffee, ~cost + size + type, trials = 29,
optimality = "D", repeats = 100)
#Extract a list of all attributes
get_optimality(designcoffee)
#Get just one attribute
get_optimality(designcoffee,"D")
# Extract from `eval_design()` output
power_output = eval_design(designcoffee, model = ~cost + size + type,
alpha = 0.05, detailedoutput = TRUE)
get_optimality(power_output)
}
| 1,761 | gpl-3.0 |
0a10b8c9548f2ea182a65da636b8259ab1032e70 | dpattermann-usgs/repgen | man/getCorrectionsPlotConfig.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/uvhydrograph-render.R
\name{getCorrectionsPlotConfig}
\alias{getCorrectionsPlotConfig}
\title{Get Corrections Plot Config}
\usage{
getCorrectionsPlotConfig(corrections, plotStartDate, plotEndDate, label, limits)
}
\arguments{
\item{corrections}{list of data objects relavant to plotting corrections data}
\item{plotStartDate}{start date of this plot}
\item{plotEndDate}{end date of this plot}
\item{label}{label of that these corrections are associated with}
\item{limits}{list of lims for all of the data which will be on here}
}
\value{
named list of gsplot calls. The name is the plotting call to make, and it points to a list of config params for that call
}
\description{
Given corrections, some information about the plot to build, will return a named list of gsplot elements to call
}
| 874 | cc0-1.0 |
10a7c90ac5861b1d001586151d9dccd190966fab | prafols/rMSIproc | man/StorePeakMatrixC.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/RcppExports.R
\name{StorePeakMatrixC}
\alias{StorePeakMatrixC}
\title{StorePeakMatrix.}
\usage{
StorePeakMatrixC(path, mat)
}
\arguments{
\item{path}{full path to directory where data must be stored.}
\item{mat}{an R List containing intensity, SNR and area matrices the mass axis vector and an R data.frame containing a normalization on each column.}
}
\description{
Stores a binned peaks matrix to HDD.
}
| 485 | gpl-3.0 |
ea6e0ae78e658695276e9c575b0bd1cbda68fec9 | hzambran/hydroPSO | man/hydroPSO.Rd | %% File hydroPSO.Rd
%% Part of the hydroPSO R package, https://github.com/hzambran/hydroPSO
%% http://cran.r-project.org/web/packages/hydroPSO
%% http://www.rforge.net/hydroPSO/
%% Copyright 2011-2018 Mauricio Zambrano-Bigiarini & Rodrigo Rojas
%% Distributed under GPL 2 or later
\name{hydroPSO}
\alias{hydroPSO}
%- Also NEED an '\alias' for EACH other topic documented here.
\title{
Enhanced Particle Swarm Optimisation algorithm
}
\description{
State-of-the-art version of the Particle Swarm Optimisation (PSO) algorithm (SPSO-2011 and SPSO-2007 capable). hydroPSO can be used as a replacement for \code{\link[stats]{optim}}, but its main focus is the calibration of environmental and other real-world model codes. Several fine-tuning options and PSO variants are available to customise the PSO engine to different calibration problems.
}
\usage{
hydroPSO(par, fn= "hydromod", ...,
method=c("spso2011", "spso2007", "ipso", "fips", "wfips", "canonical"),
lower=-Inf, upper=Inf, control=list(),
model.FUN=NULL, model.FUN.args=list() )
}
%- maybe also 'usage' for other objects documented here.
\arguments{
\item{par}{
OPTIONAL. numeric with a first guess for the parameters to be optimised, with length equal to the dimension of the solution space \cr
All the particles are randomly initialised according to the value of \code{Xini.type}. If the user provides \env{m} parameter sets for \code{par}, they are used to overwrite the first \env{m} parameter sets randomly defined according to the value of \code{Xini.type}. If some elements in \code{par} are non finite (lower than \code{lower} or larger than \code{upper}) they are ignored
}
\item{fn}{
function or character with the name of a valid R function to be optimised (minimized or maximized). The character value \sQuote{hydromod} is used to specify that an R-external model code (i.e., an executable file that needs to be run from the system console) will be analised instead of an R function \cr
-) When \code{fn!='hydromod'}, the first argument of \code{fn} has to be a vector of parameters over which optimisation is going to take place. It should return a scalar result. When \code{fn!='hydromod'} the algorithm uses the value(s) returned by \code{fn} as both model output and its corresponding goodness-of-fit measure \cr
-) When \code{fn=='hydromod'} the algorithm will optimise the model defined by \code{model.FUN} and \code{model.args}, which are used to extract the values simulated by the model and to compute its corresponding goodness-of-fit measure
}
\item{\dots}{
OPTIONAL. Only used when \code{fn!='hydromod' & fn!='hydromodInR'}. \cr
further arguments to be passed to \code{fn}.
}
\item{method}{
character, variant of the PSO algorithm to be used. By default \code{method='spso2011'}, while valid values are \sQuote{spso2011}, \sQuote{spso2007}, \sQuote{ipso}, \sQuote{fips}, \sQuote{wfips}, \sQuote{canonical}:\cr
\kbd{spso2011}: At each iteration particles are attracted to its own best-known \sQuote{personal} and to the best-known position in its \sQuote{local} neighbourhood, which depens on the value of \code{topology}. In addition, values of the PSO engine are set to the values defined in the Standard PSO 2011 (SPSO 2011, see Clerc 2012) \cr
\kbd{spso2007}: As in \code{method='spso2011'}, but with values of the PSO engine set to the values defined in the Standard PSO 2007 (SPSO 2007, see Clerc 2012) \cr
\kbd{ipso}: at each iteration particles in the swarm are rearranged in descending order according to their goodness-of-fit and the best \code{ngbest} particles are used to modify particles' position and velocity (see Zhao, 2006). Each particle is connected to a neighbourhood of particles depending on the \code{topology} value \cr
\kbd{fips}: at each iteration ALL particles contribute to modify the particles' position and velocity (see Mendes et al., 2004). Each particle is connected to a neighbourhood of particles depending on the \code{topology} value \cr
\kbd{wfips}: same implementation as \kbd{fips} method, but the contribution of each particle is weighted according to their goodness-of-fit value (see Mendes et al., 2004) \cr
\kbd{canonical}: It corresponds to the first formulation of the PSO algorithm, and it is included here for educational and comparative purposes only, due to several limitations described in literature (see Kennedy 2006). At each iteration, particles are attracted to its own best-known \sQuote{personal} and to the best-known position in all the swarm (\sQuote{global}). The following \code{control} arguments are set when this method is selected: (i) \code{npart=40}, (ii) \code{topology='gbest'}, (iii) \code{Xini.type='random'}, (iv) \code{Vini.type='random2007'}, (v) \code{use.CF=TRUE}, (vi) \code{c1=2.05}, (vii) \code{c2=2.05}, (viii) \code{boundary.wall='absorbing2007'}, (ix) \code{lambda=1.0}
}
\item{lower}{
numeric, lower boundary for each parameter \cr
Note for \code{\link[stats]{optim}} users: in \kbd{hydroPSO} the length of \code{lower} and \code{upper} are used to defined the dimension of the solution space
}
\item{upper}{
numeric, upper boundary for each parameter \cr
Note for \code{\link[stats]{optim}} users: in \kbd{hydroPSO} the length of \code{lower} and \code{upper} are used to defined the dimension of the solution space
}
\item{control}{
a list of control parameters. See \sQuote{Details}
}
\item{model.FUN}{
OPTIONAL. Used only when \code{fn='hydromod'} \cr
character, valid R function representing the model code to be calibrated/optimised
}
\item{model.FUN.args}{
OPTIONAL. Used only when \code{fn='hydromod'} \cr
list with the arguments to be passed to \code{model.FUN}
}
}
\details{
By default the hydroPSO function performs minimization of \code{fn}, but it will maximize \code{fn} if \code{MinMax='max'} \cr
The default control arguments in hydroPSO implements the Standard PSO 2011 - SPSO2011 (see Clerc 2012; Clerc et al., 2010). At the same time, hydroPSO function provides options for clamping the maximal velocity, regrouping strategy when premature convergence is detected, time-variant acceleration coefficients, time-varying maximum velocity, (non-)linear / random / adaptive / best-ratio inertia weight definitions, random or LHS initialization of positions and velocities, synchronous or asynchronous update, 4 alternative neighbourhood topologies among others
The \code{control} argument is a list that can supply any of the following components:
\describe{
\item{drty.in}{
OPTIONAL. Used only when \code{fn='hydromod'} \cr
character, name of the directory storing the input files required for PSO, i.e. \sQuote{ParamRanges.txt} and \sQuote{ParamFiles.txt}
}
\item{drty.out}{
character, path to the directory storing the output files generated by hydroPSO
}
\item{param.ranges}{
OPTIONAL. Used only when \code{fn='hydromod'} \cr
character, name of the file defining the minimum and maximum boundary values for each one of the parameters to be calibrated
}
\item{digits}{
OPTIONAL. Used only when \code{write2disk=TRUE} \cr
numeric, number of significant digits used for writing the output files with scientific notation
}
\item{MinMax}{
character, indicates whether a maximization or minimization problem needs to be solved. Valid values are in: \code{c('min', 'max')}. Default value is \kbd{min}
}
\item{npart}{
numeric, number of particles in the swarm. By default \code{npart=NA}, which means that the swarm size depends on the value of \code{method}: \cr
when \code{method='spso2007'} \code{npart=ceiling(10+2*sqrt(n))}, or \code{npart=40} otherwise
}
\item{maxit}{
numeric, maximum number of iterations. By default \code{maxit=1000}
}
\item{maxfn}{
numeric, maximum number of function evaluations. Default value is \code{+Inf}\cr
When \code{fn=='hydromod'}, this stopping criterion uses the number of \emph{effective} function calls, i.e. those function calls with a finite output value
}
\item{c1}{
numeric, cognitive acceleration coefficient. Encourages the exploitation of the solution space and reflects how much the particle is influenced by its own best-known position \cr
By default \code{c1= 0.5 + log(2)}
}
\item{c2}{
numeric, social acceleration coefficient. Encourages the exploration of the current global best and reflects how much the particle is influenced by the best-known optimum of the swarm \cr
By default \code{c2= 0.5 + log(2)}
}
\item{use.IW}{
logical, indicates if an inertia weight (\env{w}) will be used to avoid swarm explosion, i.e. particles flying around their best position without converging into it (see Shi and Eberhart, 1998) \cr
By default \code{use.IW=TRUE}
}
\item{IW.w}{
OPTIONAL. Used only when \code{use.IW= TRUE \& IW.type!='GLratio'} \cr
numeric, value of the inertia weight(s) (\env{w} or \env{[w.ini, w.fin]}). It can be a single number which is used for all iterations, or it can be a vector of length 2 with the initial and final values (in that order) that \env{w} will take along the iterations \cr
By default \code{IW.w=1/(2*log(2))}
}
\item{use.CF}{
logical, indicates if the Clerc's Constriction Factor (see Clerc, 1999; Eberhart and Shi, 2000; Clerc and Kennedy, 2002) is used to avoid swarm explosion \cr
By default \code{use.CF=FALSE}
}
\item{lambda}{
numeric in [0,1], represents a percentage to limit the maximum velocity (Vmax) for each dimension, which is computed as \code{vmax = lambda*(Xmax-Xmin)} \cr
By default \code{lambda=1}
}
\item{abstol}{
numeric, absolute convergence tolerance. The algorithm stops if \code{gbest <= abstol} (minimisation problems) OR when \code{gbest >= abstol} (maximisation problems) \cr
By default it is set to \code{-Inf} or \code{+Inf} for minimisation or maximisation problems, respectively
}
\item{reltol}{
numeric, relative convergence tolerance. The algorithm stops if the absolute difference between the best \sQuote{personal best} in the current iteration and the best \sQuote{personal best} in the previous iteration is less or equal to \code{reltol}. Defaults to \code{sqrt(.Machine$double.eps)}, typically, about 1e-8\cr
If \code{reltol} is set to \code{0}, this stopping criterion is not used
}
\item{Xini.type}{
character, indicates how to initialise the particles' positions in the swarm within the ranges defined by \code{lower} and \code{upper}. Valid values are: \cr
-) \kbd{lhs}: Latin Hypercube initialisation of positions, using \code{npart} number of strata to divide each parameter range. \bold{It requires the \pkg{lhs} package} \cr
-) \kbd{random}: random initialisation of positions within \code{lower} and \code{upper} \cr
By default \code{Xini.type='random'}
}
\item{Vini.type}{
character, indicates how to initialise the particles' velocities in the swarm. Valid values are: \cr
-) \kbd{random2011}: random initialisation of velocities within \code{lower-Xini} and \code{upper-Xini}, as defined in SPSO 2011 (\samp{Vini=U(lower-Xini, upper-Xini)}) (see Clerc, 2012, 2010) \cr
-) \kbd{lhs2011}: same as in \kbd{random2011}, but using a Latin Hypercube initialisation with \code{npart} number of strata instead of a random uniform distribution for each parameter. \bold{It requires the \pkg{lhs} package} \cr
-) \kbd{random2007}: random initialisation of velocities within \code{lower} and \code{upper} using the \sQuote{half-diff} method defined in SPSO 2007 (\samp{Vini=[U(lower, upper)-Xini]/2}) (see Clerc, 2012, 2010) \cr
-) \kbd{lhs2007}: same as in \kbd{random2007}, but using a Latin Hypercube initialisation with \code{npart} number of strata instead of a random uniform distribution for each parameter. \bold{It requires the \pkg{lhs} package} \cr
-) \kbd{zero}: all the particles are initialised with zero velocity \cr
By default \code{Vini.type=NA}, which means that \code{Vini.type} depends on the value of \code{method}: when \kbd{method='spso2007'} \code{Vini.type='random2007'}, or \code{Vini.type='random2011'} otherwise
}
\item{best.update}{
character, indicates how (when) to update the global/neighbourhood and personal best. Valid values are: \cr
-)\kbd{sync}: the update is made synchronously, i.e. after computing the position and goodness-of-fit for ALL the particles in the swarm. This is the DEFAULT option\cr
-)\kbd{async}: the update is made asynchronously, i.e. after computing the position and goodness-of-fit for EACH individual particle in the swarm
}
\item{random.update}{
OPTIONAL. Only used when \code{best.update='async'}\cr
logical, if \code{TRUE} the particles are processed in random order to update their personal best and the global/neighbourhood best \cr
By default \code{random.update=TRUE}
}
\item{boundary.wall}{
character, indicates the type of boundary condition to be applied during optimisation. Valid values are: \code{NA}, \sQuote{absorbing2011}, \sQuote{absorbing2007}, \sQuote{reflecting}, \sQuote{damping}, \sQuote{invisible} \cr
By default \code{boundary.wall=NA}, which means that \code{boundary.wall} depends on the value of \code{method}: when \kbd{method='spso2007'} \code{boundary.wall='absorbing2007'}, or \code{boundary.wall='absorbing2011'} otherwise\cr
Experience has shown that Clerc's constriction factor and the inertia weights do not always confine the particles within the solution space. To address this problem, Robinson and Rahmat-Samii (2004) and Huang and Mohan (2005) propose different boundary conditions, namely, \kbd{reflecting}, \kbd{damping}, \kbd{absorbing} and \kbd{invisible} to define how particles are treated when reaching the boundary of the searching space (see Robinson and Rahmat-Samii (2004) and Huang and Mohan (2005) for further details)
}
\item{topology}{
character, indicates the neighbourhood topology used in hydroPSO. Valid values are in \code{c('random', 'gbest', 'lbest', 'vonNeumann')}: \cr
-) \kbd{gbest}: every particle is connected to each other and, hence the global best influences all particles in the swarm. This is also termed \samp{star} topology, and it is generally assumed to have a fast convergence but is more vulnerable to the attraction to sub-optimal solutions (see Kennedy, 1999; Kennedy and Mendes, 2002, Schor et al., 2010) \cr
-) \kbd{lbest}: each particle is connected to its \code{K} immediate neighbours only. This is also termed \samp{circles} or \samp{ring} topology, and generally the swarm will converge slower than the \kbd{gbest} topology but it is less vulnerable to sub-optimal solutions (see Kennedy, 1999; Kennedy and Mendes, 2002) \cr
-) \kbd{vonNeumann}: each particle is connected to its \code{K=4} immediate neighbours only. This topology is more densely connected than \samp{lbest} but less densely than \samp{gbest}, thus, showing some parallelism with \samp{lbest} but benefiting from a bigger neighbourhood (see Kennedy and Mendes, 2003) \cr
-) \kbd{random}: the random topology is a special case of \samp{lbest} where connections among particles are randomly modified after an iteration showing no improvement in the global best (see Clerc, 2005; Clerc, 2010) \cr
By default \code{topology='random'}
}
\item{K}{
OPTIONAL. Only used when \code{topology} is in \code{c(random, lbest, vonNeumann)} \cr
numeric, neighbourhood size, i.e. the number of informants for each particle (including the particle itself) to be considered in the computation of their personal best \cr
When \code{topology=lbest} \code{K} MUST BE an even number in order to consider the same amount of neighbours to the left and the right of each particle \cr
As special case, \code{K} could be equal to \code{npart}. By default \code{K=3}
}
\item{iter.ini}{
OPTIONAL. Only used when \code{topology=='lbest'} \cr
numeric, number of iterations for which the \kbd{gbest} topology will be used before using the \kbd{lbest} topology for the computation of the personal best of each particle\cr
This option aims at making faster the identification of the global zone of attraction \cr
By default \code{iter.ini=0}
}
\item{ngbest}{
OPTIONAL. Only used when \code{method=='ipso'} \cr
numeric, number of particles considered in the computation of the global best \cr
By default \code{ngbest=4} (see Zhao, 2006)
}
\item{normalise}{
logical, indicates whether the parameter values have to be normalised to the [0,1] interval during the optimisation or not\cr
This option appears in the C and Matlab version of SPSO-2011 (See \url{http://www.particleswarm.info/standard_pso_2011_c.zip}) and there it is recommended to use this option when the search space is not an hypercube. If the search space is an hypercube, it is better not normalise (there is a small difference between the position without any normalisation and the de-normalised one). By default \code{normalise=FALSE}
}
\item{IW.type}{
OPTIONAL. Used only when \code{use.IW= TRUE} AND \code{length(IW.w)>1}\cr
character, defines how the inertia weight \env{w} will vary along iterations. Valid values are: \cr
-)\kbd{linear}: \env{w} varies linearly between the initial and final values specified in \code{IW.w} (see Shi and Eberhart, 1998; Zheng et al., 2003). This is the DEFAULT option \cr
-)\kbd{non-linear}: \env{w} varies non-linearly between the initial and final values specified in \code{IW.w} with exponential factor \kbd{IW.exp} (see Chatterjee and Siarry, 2006) \cr
-)\kbd{runif}: \env{w} is a uniform random variable in the range \env{[w.min, w.max]} specified in \code{IW.w}. It is a generalisation of the weight proposed in Eberhart and Shi (2001b) \cr
-)\kbd{aiwf}: adaptive inertia weight factor, where the inertia weight is varied adaptively depending on the goodness-of-fit values of the particles (see Liu et al., 2005) \cr
-)\kbd{GLratio}: \env{w} varies according to the ratio between the global best and the average of the particle's local best (see Arumugam and Rao, 2008) \cr
By default \code{IW.type='linear'}
}
\item{IW.exp}{
OPTIONAL. Used only when \code{use.IW=TRUE} AND \code{IW.type='non-linear'} \cr
numeric, non-linear modulation index (see Chatterjee and Siarry, 2006) \cr
When \code{IW.type='linear'}, \code{IW.exp} is set to 1. By default \code{IW.exp=1}
}
\item{use.TVc1}{
logical, indicates if the cognitive acceleration coefficient \code{c1} will have a time-varying value instead of a constant one provided by the user (see Ratnaweera et al. 2004). By default \code{use.TVc1=FALSE}
}
\item{TVc1.type}{
character, required only when \code{use.TVc1 = TRUE}. Valid values are: \cr
-)\kbd{linear}: \env{c1} varies linearly between the initial and final values specified in \code{TVc1.rng} (see Ratnaweera et al., 2004) \cr
-)\kbd{non-linear}: \env{c1} varies non-linearly between the initial and final values specified in \code{TVc1.rng}. Proposed by the authors of hydroPSO taking into account the work of Chatterjee and Siarry (2006) for the inertia weight \cr
-)\kbd{GLratio}: \env{c1} varies according to the ratio between the global best and the average of the particle's local best (see Arumugam and Rao, 2008) \cr
By default \code{TVc1.type='linear'}
}
\item{TVc1.rng}{
OPTIONAL. Used only when \code{use.TVc1=TRUE} AND \code{TVc1.type!='GLratio'} \cr
numeric, initial and final values for the cognitive acceleration coefficient \env{[c1.ini, c1.fin]} (in that order) along the iterations \cr
By default \code{TVc1.rng=c(1.28, 1.05)}
}
\item{TVc1.exp}{
OPTIONAL. Used only when \code{use.TVc1= TRUE} AND \code{TVc1.type= 'non-linear'} \cr
numeric, non-linear modulation index \cr
When \code{TVc1.exp} is equal to 1, \code{TVc1} corresponds to the improvement proposed by Ratnaweera et al., (2004), whereas when \code{TVc1.exp} is different from one, no reference has been found in literature by the authors, but it was included as an option based on the work of Chatterjee and Siarry (2006) for the inertia weight \cr
When \code{TVc1.type='linear'}, \code{TVc1.exp} is automatically set to 1. By default \code{TVc1.exp=1}
}
\item{use.TVc2}{
logical, indicates whether the social acceleration coefficient \code{c2} will have a time-varying value or a constant one provided by the user (see Ratnaweera et al. 2004). By default \code{use.TVc2=FALSE}
}
\item{TVc2.type}{
character, required only when \code{use.TVc2=TRUE}. Valid values are: \cr
-)\kbd{linear}: \env{c2} varies linearly between the initial and final values specified in \code{TVc2.rng} (see Ratnaweera et al. 2004) \cr
-)\kbd{non-linear}: \env{c2} varies non-linearly between the initial and final values specified in \code{TVc2.rng}. Proposed by the authors of hydroPSO taking into account the work of Chatterjee and Siarry (2006) for the inertia weight \cr
By default \code{TVc2.type='linear'}
}
\item{TVc2.rng}{
OPTIONAL. Used only when \code{use.TVc2=TRUE} \cr
numeric, initial and final values for the social acceleration coefficient \env{[c2.ini, c2.fin]} (in that order) along the iterations \cr
By default \code{TVc2.rng=c(1.05, 1.28)}
}
\item{TVc2.exp}{
OPTIONAL. Used only when \code{use.TVc2= TRUE} AND \code{TVc2.type='non-linear'} \cr
numeric, non-linear modulation index \cr
When \code{TVc2.exp} is equal to 1, \code{TVc2} corresponds to the improvement proposed by Ratnaweera et al., 2004, whereas when \code{TVc2.exp} is different from one, no reference has been found in literature by the authors, but it was included as an option based on the work of Chatterjee and Siarry (2006) for the inertia weight \cr
When \code{TVc2.type= linear}, \code{TVc2.exp} is automatically set to 1. By default \code{TVc2.exp=1}
}
\item{use.TVlambda}{
logical, indicates whether the percentage to limit the maximum velocity \code{lambda} will have a time-varying value or a constant value provided by the user. Proposed by the authors of hydroPSO based on the work of Chatterjee and Siarry (2006) for the inertia weight\cr
By default \code{use.TVlambda=FALSE}
}
\item{TVlambda.type}{
character, required only when \code{use.TVlambda=TRUE}. Valid values are: \cr
-)\kbd{linear}: \env{TVvmax} varies linearly between the initial and final values specified in \code{TVlambda.rng} \cr
-)\kbd{non-linear}: \env{TVvmax} varies non-linearly between the initial and final values specified in \code{TVlambda.rng} \cr
By default \code{TVlambda.type='linear'}
}
\item{TVlambda.rng}{
OPTIONAL. Used only when \code{use.TVlambda=TRUE} \cr
numeric, initial and final values for the percentage to limit the maximum velocity \env{[TVlambda.ini, TVlambda.fin]} (in that order) along the iterations \cr
By default \code{TVlambda.rng=c(1, 0.25)}
}
\item{TVlambda.exp}{
OPTIONAL. only required when \code{use.TVlambda= TRUE} AND \code{TVlambda.type='non-linear'} \cr
numeric, non-linear modulation index \cr
When \code{TVlambda.type='linear'}, \code{TVlambda.exp} is automatically set to 1. By default \code{TVlambda.exp=1}
}
\item{use.RG}{
logical, indicates if the swarm should be regrouped when premature convergence is detected. By default \code{use.RG=FALSE} \cr
When \code{use.RG=TRUE} the swarm is regrouped in a search space centred around the current global best. This updated search space is hoped to be both small enough for efficient search and large enough to allow the swarm to escape from stagnation (see Evers and Ghalia, 2009)\cr
There are 4 differences wrt Evers and Ghalia 2009: \cr
-) swarm radius: median is used instead of max \cr
-) computation of the new range of parameter space, which corresponds to the boundaries of the whole swarm at a given iteration, instead of the maximum values of \sQuote{abs(x-Gbest)} \cr
-) regrouping factor: \code{RG.r} instead of \sQuote{6/(5*ro)} \cr
-) velocity is re-initialized using \code{Vini.type} instead of using the formula proposed by Evers and Ghalia 2009
}
\item{RG.thr}{
ONLY required when \code{use.RG=TRUE} \cr
numeric, positive number representing the \kbd{stagnation threshold} used to decide whether the swarm has to be regrouped or not. See Evers and Galia (2009) for further details \cr
Regrouping occurs when the \emph{normalised swarm radius} is less than \code{RG.thr}. By default \code{RG.thr=1E-5}
}
\item{RG.r}{
ONLY required when \code{use.RG=TRUE}. \cr
numeric, positive number representing the \kbd{regrouping factor}, which is used to regroup the swarm in a search space centred around the current global best (see Evers and Galia, 2009 for further details). By default \code{RG.thr=2}
}
\item{RG.miniter}{
ONLY required when \code{use.RG=TRUE} \cr
numeric, minimum number of iterations needed before each new regrouping. By default \code{RG.miniter=100}
}
%% \item{use.DS}{
%%CPSO
%%}
%% \item{DS.r}{
%% ~~Describe \code{DS.r} here~~
%%}
%% \item{DS.tol}{
%% ~~Describe \code{DS.tol} here~~
%%}
%% \item{DS.dmin}{
%% ~~Describe \code{DS.dmin} here~~
%%}
\item{plot}{
logical, indicates if a two-dimensional plot with the particles' position will be drawn after each iteration. For high dimensional functions, only the first two dimensions of all the particles are plotted\cr
By default \code{plot=FALSE}
}
\item{out.with.pbest}{
logical, indicates if the best parameter values for each particle and their goodness-of-fit will be included in the output of the algorithm\cr
By default \code{out.with.pbest=FALSE}
}
\item{out.with.fit.iter}{
logical, indicates if the goodness-of-fit of each particle for each iteration will be included in the output of the algorithm\cr
By default \code{out.with.fit.iter=FALSE}
}
\item{write2disk}{
logical, indicates if the output files will be written to the disk. By default \code{write2disk=TRUE}
}
\item{verbose}{
logical, indicates if progress messages are to be printed. By default \code{verbose=TRUE}
}
\item{REPORT}{
OPTIONAL. Used only when \code{verbose=TRUE} \cr
The frequency of report messages printed to the screen. Default to every 100 iterations
}
\item{parallel}{
character, indicates how to parallelise \sQuote{hydroPSO} (to be precise, only the evaluation of the objective function \code{fn} is parallelised). Valid values are: \cr
-)\kbd{none}: no parallelisation is made (this is the default value)\cr
-)\kbd{multicore}: DEPRECATED!, since \code{multicore} package is not in CRAN anymore. Originally it was thought to carry out parallel computations for machines with multiple cores or CPUs. The evaluation of the objective function \code{fn} is done with the \code{\link[parallel]{mclapply}} function of the \pkg{parallel} package. It requires POSIX-compliant OS (essentially anything but Windows) \cr
-)\kbd{parallel}: parallel computations for network clusters or machines with multiple cores or CPUs. A \sQuote{FORK} cluster is created with the \code{\link[parallel]{makeForkCluster}} function. When \code{fn.name="hydromod"} the evaluation of the objective function \code{fn} is done with the \code{\link[parallel]{clusterApply}} function of the \pkg{parallel} package. When \code{fn.name!="hydromod"} the evaluation of the objective function \code{fn} is done with the \code{\link[parallel]{parRapply}} function of the \pkg{parallel} package.\cr
-)\kbd{parallelWin}: parallel computations for network clusters or machines with multiple cores or CPUs (this is the only parallel implementation that works on Windows machines). A \sQuote{PSOCK} cluster is created with the \code{\link[parallel]{makeCluster}} function. When \code{fn.name="hydromod"} the evaluation of the objective function \code{fn} is done with the \code{\link[parallel]{clusterApply}} function of the \pkg{parallel} package. When \code{fn.name!="hydromod"} the evaluation of the objective function \code{fn} is done with the \code{\link[parallel]{parRapply}} function of the \pkg{parallel} package.
}
\item{par.nnodes}{
OPTIONAL. Used only when \code{parallel!='none'} \cr
numeric, indicates the number of cores/CPUs to be used in the local multi-core machine, or the number of nodes to be used in the network cluster. \cr
By default \code{par.nnodes} is set to the amount of cores detected by the function \code{detectCores()} (\pkg{multicore} or \pkg{parallel} package)
}
\item{par.pkgs}{
OPTIONAL. Used only when \code{parallel='parallelWin'} \cr
list of package names (as characters) that need to be loaded on each node for allowing the objective function \code{fn} to be evaluated
}
}
}
\value{
A list, compatible with the output from \code{\link[stats]{optim}}, with components:
\item{par}{
optimum parameter set found
}
\item{value}{
value of \code{fn} corresponding to \code{par}
}
\item{counts}{
three-element vector containing the total number of function calls, number of iterations, and number of regroupings
}
\item{convergence}{
integer code where \code{0} indicates that the algorithm terminated by reaching the absolute tolerance, otherwise:
\describe{
\item{1}{relative tolerance reached}
\item{2}{maximum number of (effective) function evaluations reached}
\item{3}{maximum number of iterations reached}
}
}
\item{message}{character string giving human-friendly information about \code{convergence}
}
}
\references{
\cite{Abdelaziz, Ramadan, and Mauricio Zambrano-Bigiarini (2014), Particle Swarm Optimization for inverse modeling of solute transport in fractured gneiss aquifer. Journal of Contaminant Hydrology, 164, 285-298. doi:10.1016/j.jconhyd.2014.06.003}
\cite{Clerc, M. Standard Particle Swarm. 2012. (SPSO-2007, SPSO-2011). \url{http://clerc.maurice.free.fr/pso/SPSO_descriptions.pdf}. Last visited [24-Sep-2012]}
\cite{Clerc, M. From Theory to Practice in Particle Swarm Optimization, Handbook of Swarm Intelligence, Springer Berlin Heidelberg, 3-36, Eds: Panigrahi, Bijaya Ketan, Shi, Yuhui, Lim, Meng-Hiot, Hiot, Lim Meng, and Ong, Yew Soon, 2010, doi: 10.1007/978-3-642-17390-5_1}
\cite{Clerc, M., Stagnation Analysis in Particle Swarm Optimisation or what happens when nothing happens. Technical Report. 2006. \url{https://hal.archives-ouvertes.fr/hal-00122031}}
\cite{Clerc, M. Particle Swarm Optimization. ISTE, 2005}
\cite{Clerc, M and J Kennedy. The particle swarm - explosion, stability, and convergence in a multidimensional complex space. IEEE Transactions On Evolutionary Computation, 6:58-73, 2002. doi:10.1109/4235.985692}
\cite{Chatterjee, A. and Siarry, P. Nonlinear inertia weight variation for dynamic adaptation in particle swarm optimization, Computers \& Operations Research, Volume 33, Issue 3, March 2006, Pages 859-871, ISSN 0305-0548, DOI: 10.1016/j.cor.2004.08.012}
\cite{Eberhart, R.C.; Shi, Y.; Comparing inertia weights and constriction factors in particle swarm optimization. Evolutionary Computation, 2000. Proceedings of the 2000 Congress on , vol.1, no., pp.84-88 vol.1, 2000. doi: 10.1109/CEC.2000.870279}
\cite{Evers, G.I.; Ben Ghalia, M. Regrouping particle swarm optimization: A new global optimization algorithm with improved performance consistency across benchmarks. Systems, Man and Cybernetics, 2009. SMC 2009. IEEE International Conference on , vol., no., pp.3901-3908, 11-14 Oct. 2009. doi: 10.1109/ICSMC.2009.5346625}
\cite{Huang, T.; Mohan, A.S.; , A hybrid boundary condition for robust particle swarm optimization. Antennas and Wireless Propagation Letters, IEEE , vol.4, no., pp. 112-117, 2005. doi: 10.1109/LAWP.2005.846166}
\cite{Kennedy, J. and R. Eberhart. Particle Swarm Optimization. in proceedings IEEE international conference on Neural networks. pages 1942-1948. 1995. doi: 10.1109/ICNN.1995.488968}
\cite{Kennedy, J.; Small worlds and mega-minds: effects of neighborhood topology on particle swarm performance. Evolutionary Computation, 1999. CEC 99. Proceedings of the 1999 Congress on , vol.3, no., pp.3 vol. (xxxvii+2348), 1999. doi: 10.1109/CEC.1999.785509}
\cite{Kennedy, J.; Mendes, R.. Population structure and particle swarm performance. Evolutionary Computation, 2002. CEC '02. Proceedings of the 2002 Congress on , vol.2, no., pp.1671-1676, 2002. doi: 10.1109/CEC.2002.1004493}
\cite{Kennedy, J.; Mendes, R.; , Neighborhood topologies in fully-informed and best-of-neighborhood particle swarms. Soft Computing in Industrial Applications, 2003. SMCia/03. Proceedings of the 2003 IEEE International Workshop on , vol., no., pp. 45- 50, 23-25 June 2003. doi: 10.1109/SMCIA.2003.1231342}
\cite{Kennedy, J. 2006. Swarm intelligence, in Handbook of Nature-Inspired and Innovative Computing, edited by A. Zomaya, pp. 187-219, Springer US, doi:10.1007/0-387-27705-6_6}
\cite{Liu, B. and L. Wang, Y.-H. Jin, F. Tang, and D.-X. Huang. Improved particle swarm optimization combined with chaos. Chaos, Solitons \& Fractals, vol. 25, no. 5, pp.1261-1271, Sep. 2005. doi:10.1016/j.chaos.2004.11.095}
\cite{Mendes, R.; Kennedy, J.; Neves, J. The fully informed particle swarm: simpler, maybe better. Evolutionary Computation, IEEE Transactions on , vol.8, no.3, pp. 204-210, June 2004. doi: 10.1109/TEVC.2004.826074}
\cite{Ratnaweera, A.; Halgamuge, S.K.; Watson, H.C. Self-organizing hierarchical particle swarm optimizer with time-varying acceleration coefficients. Evolutionary Computation, IEEE Transactions on , vol.8, no.3, pp. 240- 255, June 2004. doi: 10.1109/TEVC.2004.826071}
\cite{Robinson, J.; Rahmat-Samii, Y.; Particle swarm optimization in electromagnetics. Antennas and Propagation, IEEE Transactions on , vol.52, no.2, pp. 397-407, Feb. 2004. doi: 10.1109/TAP.2004.823969}
\cite{Shi, Y.; Eberhart, R. A modified particle swarm optimizer. Evolutionary Computation Proceedings, 1998. IEEE World Congress on Computational Intelligence. The 1998 IEEE International Conference on , vol., no., pp.69-73, 4-9 May 1998. doi: 10.1109/ICEC.1998.699146}
\cite{Schor, D.; Kinsner, W.; Anderson, J.; A study of optimal topologies in swarm intelligence. Electrical and Computer Engineering (CCECE), 2010 23rd Canadian Conference on , vol., no., pp.1-8, 2-5 May 2010. doi: 10.1109/CCECE.2010.5575132}
\cite{Yong-Ling Zheng; Long-Hua Ma; Li-Yan Zhang; Ji-Xin Qian. On the convergence analysis and parameter selection in particle swarm optimization. Machine Learning and Cybernetics, 2003 International Conference on , vol.3, no., pp. 1802-1807 Vol.3, 2-5 Nov. 2003. doi: 10.1109/ICMLC.2003.1259789}
\cite{Zambrano-Bigiarini, M.; R. Rojas (2013), A model-independent Particle Swarm Optimisation software for model calibration, Environmental Modelling & Software, 43, 5-25, doi:10.1016/j.envsoft.2013.01.004}
\cite{Zambrano-Bigiarini, M., M. Clerc, R. Rojas (2013), Standard Particle Swarm Optimisation 2011 at CEC-2013: A baseline for future PSO improvements, In Proceedings of 2013 IEEE Congress on Evolutionary Computation (CEC'2013). doi:10.1109/CEC.2013.6557848}
\cite{Zhao, B. An Improved Particle Swarm Optimization Algorithm for Global Numerical Optimization. In Proceedings of International Conference on Computational Science (1). 2006, 657-664}
\cite{Lynn, N., Ali, M. Z., & Suganthan, P. N. (2018). Population topologies for particle swarm optimization and differential evolution. Swarm and evolutionary computation, 39, 24-35. doi: 10.1016/j.swevo.2017.11.002}
}
\author{
Mauricio Zambrano-Bigiarini, \email{[email protected]}
}
\note{
Note for \code{\link[stats]{optim}} users: \cr
1) In \kbd{hydroPSO} the length of \code{lower} and \code{upper} are used to define the dimension of the solution space (not the length of \code{par}) \cr
2) In \kbd{hydroPSO}, \code{par} may be omitted. If not omitted, the \env{m} parameter sets provided by the user for \code{par} are used to overwrite the first \env{m} parameter sets randomly defined according to the value of \code{Xini.type} \cr
}
%% ~Make other sections like Warning with \section{Warning }{....} ~
\seealso{
\code{\link[stats]{optim}}
}
\examples{
# Number of dimensions of the optimisation problem (for all the examples)
D <- 5
# Boundaries of the search space (Rastrigin function)
lower <- rep(-5.12, D)
upper <- rep(5.12, D)
\donttest{
################################
# Example 1. Basic use #
################################
# Setting the seed (for reproducible results)
set.seed(100)
# Basic use 1. Rastrigin function (non-linear and multi-modal with many local minima)
# Results are not saved to the hard disk, for faster execution ('write2disk=FALSE')
hydroPSO(fn=rastrigin, lower=lower, upper=upper, control=list(write2disk=FALSE) )
} # donttest END
\dontrun{
setwd("~")
# Basic use 2. Rastrigin function (non-linear and multimodal with many local minima)
# Results are saved to the hard disk. Slower than before but results are kept for
# future inspection
hydroPSO(fn=rastrigin, lower=lower, upper=upper )
# Plotting the results, by default into the active graphic device
# 'MinMax="min"' indicates a minimisation problem
plot_results(MinMax="min")
# Plotting the results into PNG files.
plot_results(MinMax="min", do.png=TRUE)
} # dontrun END
\donttest{
################################
# Example 2. More advanced use #
################################
# Defining the relative tolerance ('reltol'), the frequency of report messages
# printed to the screen ('REPORT'), and no output files ('write2disk')
set.seed(100)
hydroPSO( fn=rastrigin, lower=lower, upper=upper,
control=list(reltol=1e-20, REPORT=10, write2disk=FALSE) )
###################################
# Example 3. von Neumman Topology #
###################################
# Same as Example 2, but using a von Neumann topology ('topology="vonNeumann"')
set.seed(100)
hydroPSO(fn=rastrigin,lower=lower,upper=upper,
control=list(topology="vonNeumann", reltol=1E-20,
REPORT=50, write2disk=FALSE) )
################################
# Example 4. Regrouping #
################################
# Same as Example 3 ('topology="vonNeumann"') but using regrouping ('use.RG')
set.seed(100)
hydroPSO(fn=rastrigin,lower=lower,upper=upper,
control=list(topology="vonNeumann", reltol=1E-20,
REPORT=50, write2disk=FALSE,
use.RG=TRUE,RG.thr=7e-2,RG.r=3,RG.miniter=50) )
################################
# Example 5. FIPS #
################################
# Same as Example 3 ('topology="vonNeumann"') but using a fully informed
# particle swarm (FIPS) variant ('method') with global best topology
set.seed(100)
hydroPSO(fn=rastrigin,lower=lower,upper=upper, method="fips",
control=list(topology="gbest",reltol=1E-9,write2disk=FALSE) )
################################
# Example 6. normalisation #
################################
# Same as Example 3 but parameter values are normalised to the [0,1] interval
# during the optimisation. This option is recommended when the search space is
# not an hypercube (not useful is this particular example)
set.seed(100)
hydroPSO(fn=rastrigin,lower=lower,upper=upper,
control=list(topology="vonNeumann", reltol=1E-20, normalise=TRUE,
REPORT=50, write2disk=FALSE) )
################################
# Example 7. Asynchronus update#
################################
# Same as Example 3, but using asynchronus update of previus and local best
# ('best.update'). Same global optimum but much slower....
set.seed(100)
hydroPSO(fn=rastrigin,lower=lower,upper=upper,
control=list(topology="vonNeumann", reltol=1E-20,
REPORT=50, write2disk=FALSE, best.update="async") )
} # donttest END
}
% Add one or more standard keywords, see file 'KEYWORDS' in the
% R documentation directory.
\keyword{optimize}
\keyword{files}
| 39,425 | gpl-2.0 |
baa7bcb228e9ec16fa2c22b28e31c96f23cbe43b | cran/rimage | man/sobel.v.Rd | \name{sobel.v}
\alias{sobel.v}
\title{Sobel filter to extract vertical edges}
\description{
This function calculates an image which sobel filter is applied.
It extracts vertical edges only. It is faster than sobel.v
extremely because utilization of a C routine.
}
\usage{sobel.v(img)}
\arguments{
\item{img}{a matrix representing target image}
}
\value{
a matrix representing the image after vertical sobel filter is applied
}
\examples{
data(logo)
plot(normalize(sobel.v(logo)))
}
\seealso{\code{\link{sobel.h}},\code{\link{sobel}}}
\keyword{misc}
| 564 | bsd-3-clause |
44a17c1ed64b63cc18f1be0e71d2c50f5c2e25fa | ronkeizer/PopED | man/test_for_max.Rd | % Generated by roxygen2 (4.1.1): do not edit by hand
% Please edit documentation in R/test_for_max.R
\name{test_for_max}
\alias{test_for_max}
\title{Test if any matrix element is above a max value.}
\usage{
test_for_max(mat, max_mat)
}
\arguments{
\item{mat}{A matrix.}
\item{max_mat}{A matrix the same size as mat with the maximum allowed value of that element.}
}
\value{
A matrix
}
\description{
Function tests is any matrix element is above a maximum value. For those elements
the function sets those values to the maximum value.
}
\examples{
test_for_max(cbind(2,3,4,5,6),cbind(4,4,4,4,4))
test_for_max(ones(6)*45,ones(6)*40)
}
\seealso{
Other matrix_manipulation: \code{\link{diag_matlab}};
\code{\link{test_for_min}}; \code{\link{test_for_zeros}}
}
| 767 | lgpl-3.0 |
fd812748f9b8af6d8b0b988142e36642e7bce394 | LiNk-NY/RTCGAToolbox | man/showResults-DGEResult.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/RTCGAToolbox-Class.R
\name{showResults,DGEResult-method}
\alias{showResults,DGEResult-method}
\alias{showResults,DGEResult,DGEResult-method}
\title{Export toptable or correlation data frame}
\usage{
\S4method{showResults}{DGEResult}(object)
}
\arguments{
\item{object}{A \code{\linkS4class{DGEResult}} or \code{\linkS4class{CorResult}} object}
}
\value{
Returns toptable for DGE results
}
\description{
Export toptable or correlation data frame
}
\examples{
data(RTCGASample)
dgeRes = getDiffExpressedGenes(RTCGASample)
dgeRes
showResults(dgeRes[[1]])
}
| 632 | gpl-2.0 |
466e22f331fdd1a03a121c8a4aa8ff63c1003ba7 | hadley/r-source | src/library/base/man/Extremes.Rd | % File src/library/base/man/Extremes.Rd
% Part of the R package, http://www.R-project.org
% Copyright 1995-2013 R Core Team
% Distributed under GPL 2 or later
\name{Extremes}
\alias{max}
\alias{min}
\alias{pmax}
\alias{pmin}
\alias{pmax.int}
\alias{pmin.int}
\title{Maxima and Minima}
\description{
Returns the (parallel) maxima and minima of the input values.
}
\usage{
max(\dots, na.rm = FALSE)
min(\dots, na.rm = FALSE)
pmax(\dots, na.rm = FALSE)
pmin(\dots, na.rm = FALSE)
pmax.int(\dots, na.rm = FALSE)
pmin.int(\dots, na.rm = FALSE)
}
\arguments{
\item{\dots}{numeric or character arguments (see Note).}
\item{na.rm}{a logical indicating whether missing values should be
removed.}
}
\details{
\code{max} and \code{min} return the maximum or minimum of \emph{all}
the values present in their arguments, as \code{\link{integer}} if
all are \code{logical} or \code{integer}, as \code{\link{double}} if
all are numeric, and character otherwise.
If \code{na.rm} is \code{FALSE} an \code{NA} value in any of the
arguments will cause a value of \code{NA} to be returned, otherwise
\code{NA} values are ignored.
The minimum and maximum of a numeric empty set are \code{+Inf} and
\code{-Inf} (in this order!) which ensures \emph{transitivity}, e.g.,
\code{min(x1, min(x2)) == min(x1, x2)}. For numeric \code{x}
\code{max(x) == -Inf} and \code{min(x) == +Inf}
whenever \code{length(x) == 0} (after removing missing values if
requested). However, \code{pmax} and \code{pmin} return
\code{NA} if all the parallel elements are \code{NA} even for
\code{na.rm = TRUE}.
\code{pmax} and \code{pmin} take one or more vectors (or matrices) as
arguments and return a single vector giving the \sQuote{parallel}
maxima (or minima) of the vectors. The first element of the result is
the maximum (minimum) of the first elements of all the arguments, the
second element of the result is the maximum (minimum) of the second
elements of all the arguments and so on. Shorter inputs (of non-zero
length) are recycled if necessary. Attributes (see
\code{\link{attributes}}: such as \code{\link{names}} or
\code{\link{dim}}) are copied from the first argument (if applicable).
\code{pmax.int} and \code{pmin.int} are faster internal versions only
used when all arguments are atomic vectors and there are no classes:
they drop all attributes. (Note that all versions fail for raw and
complex vectors since these have no ordering.)
\code{max} and \code{min} are generic functions: methods can be
defined for them individually or via the
\code{\link[=S3groupGeneric]{Summary}} group generic. For this to
work properly, the arguments \code{\dots} should be unnamed, and
dispatch is on the first argument.
By definition the min/max of a numeric vector containing an \code{NaN}
is \code{NaN}, except that the min/max of any vector containing an
\code{NA} is \code{NA} even if it also contains an \code{NaN}.
Note that \code{max(NA, Inf) == NA} even though the maximum would be
\code{Inf} whatever the missing value actually is.
Character versions are sorted lexicographically, and this depends on
the collating sequence of the locale in use: the help for
\sQuote{\link{Comparison}} gives details. The max/min of an empty
character vector is defined to be character \code{NA}. (One could
argue that as \code{""} is the smallest character element, the maximum
should be \code{""}, but there is no obvious candidate for the
minimum.)
}
\value{
For \code{min} or \code{max}, a length-one vector. For \code{pmin} or
\code{pmax}, a vector of length the longest of the input vectors, or
length zero if one of the inputs had zero length.
The type of the result will be that of the highest of the inputs in
the hierarchy integer < double < character.
For \code{min} and \code{max} if there are only numeric inputs and all
are empty (after possible removal of \code{NA}s), the result is double
(\code{Inf} or \code{-Inf}).
}
\section{S4 methods}{
\code{max} and \code{min} are part of the S4
\code{\link[=S4groupGeneric]{Summary}} group generic. Methods
for them must use the signature \code{x, \dots, na.rm}.
}
\references{
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
\emph{The New S Language}.
Wadsworth & Brooks/Cole.
}
\note{
\sQuote{Numeric} arguments are vectors of type integer and numeric,
and logical (coerced to integer). For historical reasons, \code{NULL}
is accepted as equivalent to \code{integer(0)}.% PR#1283
\code{pmax} and \code{pmin} will also work on classed objects with
appropriate methods for comparison, \code{is.na} and \code{rep} (if
recycling of arguments is needed).
}
\seealso{
\code{\link{range}} (\emph{both} min and max) and
\code{\link{which.min}} (\code{which.max}) for the \emph{arg min},
i.e., the location where an extreme value occurs.
\sQuote{\link{plotmath}} for the use of \code{min} in plot annotation.
}
\examples{
require(stats); require(graphics)
min(5:1, pi) #-> one number
pmin(5:1, pi) #-> 5 numbers
x <- sort(rnorm(100)); cH <- 1.35
pmin(cH, quantile(x)) # no names
pmin(quantile(x), cH) # has names
plot(x, pmin(cH, pmax(-cH, x)), type = "b", main = "Huber's function")
cut01 <- function(x) pmax(pmin(x, 1), 0)
curve( x^2 - 1/4, -1.4, 1.5, col = 2)
curve(cut01(x^2 - 1/4), col = "blue", add = TRUE, n = 500)
## pmax(), pmin() preserve attributes of *first* argument
D <- diag(x = (3:1)/4) ; n0 <- numeric()
stopifnot(identical(D, cut01(D) ),
identical(n0, cut01(n0)),
identical(n0, cut01(NULL)),
identical(n0, pmax(3:1, n0, 2)),
identical(n0, pmax(n0, 4)))
}
\keyword{univar}
\keyword{arith}
| 5,740 | gpl-2.0 |
2395552b039c590622ec7ba163a03ee81d00fb3b | opendatagroup/hadrian | aurelius/man/pfa.HoltWinters.Rd | % Generated by roxygen2: do not edit by hand
% Please edit documentation in R/holtwinters.R
\name{pfa.HoltWinters}
\alias{pfa.HoltWinters}
\title{PFA Formatting of Fitted Holt Winters Models}
\source{
pfa_config.R avro_typemap.R avro.R pfa_cellpool.R pfa_expr.R pfa_utils.R
}
\usage{
\method{pfa}{HoltWinters}(object, name = NULL, version = NULL, doc = NULL,
metadata = NULL, randseed = NULL, options = NULL, ...)
}
\arguments{
\item{object}{an object of class "HoltWinters"}
\item{name}{a character which is an optional name for the scoring engine}
\item{version}{an integer which is sequential version number for the model}
\item{doc}{a character which is documentation string for archival purposes}
\item{metadata}{a \code{list} of strings that is computer-readable documentation for
archival purposes}
\item{randseed}{a integer which is a global seed used to generate all random
numbers. Multiple scoring engines derived from the same PFA file have
different seeds generated from the global one}
\item{options}{a \code{list} with value types depending on option name
Initialization or runtime options to customize implementation
(e.g. optimization switches). May be overridden or ignored by PFA consumer}
\item{...}{additional arguments affecting the PFA produced}
}
\value{
a \code{list} of lists that compose valid PFA document
}
\description{
This function takes a Holt Winters model fit using HoltWinters()
and returns a list-of-lists representing in valid PFA document
that could be used for scoring
}
\examples{
model <- HoltWinters(co2)
model_as_pfa <- pfa(model)
}
\seealso{
\code{\link[stats]{HoltWinters}} \code{\link{extract_params.HoltWinters}}
}
| 1,680 | apache-2.0 |
466e22f331fdd1a03a121c8a4aa8ff63c1003ba7 | cmosetick/RRO | R-src/src/library/base/man/Extremes.Rd | % File src/library/base/man/Extremes.Rd
% Part of the R package, http://www.R-project.org
% Copyright 1995-2013 R Core Team
% Distributed under GPL 2 or later
\name{Extremes}
\alias{max}
\alias{min}
\alias{pmax}
\alias{pmin}
\alias{pmax.int}
\alias{pmin.int}
\title{Maxima and Minima}
\description{
Returns the (parallel) maxima and minima of the input values.
}
\usage{
max(\dots, na.rm = FALSE)
min(\dots, na.rm = FALSE)
pmax(\dots, na.rm = FALSE)
pmin(\dots, na.rm = FALSE)
pmax.int(\dots, na.rm = FALSE)
pmin.int(\dots, na.rm = FALSE)
}
\arguments{
\item{\dots}{numeric or character arguments (see Note).}
\item{na.rm}{a logical indicating whether missing values should be
removed.}
}
\details{
\code{max} and \code{min} return the maximum or minimum of \emph{all}
the values present in their arguments, as \code{\link{integer}} if
all are \code{logical} or \code{integer}, as \code{\link{double}} if
all are numeric, and character otherwise.
If \code{na.rm} is \code{FALSE} an \code{NA} value in any of the
arguments will cause a value of \code{NA} to be returned, otherwise
\code{NA} values are ignored.
The minimum and maximum of a numeric empty set are \code{+Inf} and
\code{-Inf} (in this order!) which ensures \emph{transitivity}, e.g.,
\code{min(x1, min(x2)) == min(x1, x2)}. For numeric \code{x}
\code{max(x) == -Inf} and \code{min(x) == +Inf}
whenever \code{length(x) == 0} (after removing missing values if
requested). However, \code{pmax} and \code{pmin} return
\code{NA} if all the parallel elements are \code{NA} even for
\code{na.rm = TRUE}.
\code{pmax} and \code{pmin} take one or more vectors (or matrices) as
arguments and return a single vector giving the \sQuote{parallel}
maxima (or minima) of the vectors. The first element of the result is
the maximum (minimum) of the first elements of all the arguments, the
second element of the result is the maximum (minimum) of the second
elements of all the arguments and so on. Shorter inputs (of non-zero
length) are recycled if necessary. Attributes (see
\code{\link{attributes}}: such as \code{\link{names}} or
\code{\link{dim}}) are copied from the first argument (if applicable).
\code{pmax.int} and \code{pmin.int} are faster internal versions only
used when all arguments are atomic vectors and there are no classes:
they drop all attributes. (Note that all versions fail for raw and
complex vectors since these have no ordering.)
\code{max} and \code{min} are generic functions: methods can be
defined for them individually or via the
\code{\link[=S3groupGeneric]{Summary}} group generic. For this to
work properly, the arguments \code{\dots} should be unnamed, and
dispatch is on the first argument.
By definition the min/max of a numeric vector containing an \code{NaN}
is \code{NaN}, except that the min/max of any vector containing an
\code{NA} is \code{NA} even if it also contains an \code{NaN}.
Note that \code{max(NA, Inf) == NA} even though the maximum would be
\code{Inf} whatever the missing value actually is.
Character versions are sorted lexicographically, and this depends on
the collating sequence of the locale in use: the help for
\sQuote{\link{Comparison}} gives details. The max/min of an empty
character vector is defined to be character \code{NA}. (One could
argue that as \code{""} is the smallest character element, the maximum
should be \code{""}, but there is no obvious candidate for the
minimum.)
}
\value{
For \code{min} or \code{max}, a length-one vector. For \code{pmin} or
\code{pmax}, a vector of length the longest of the input vectors, or
length zero if one of the inputs had zero length.
The type of the result will be that of the highest of the inputs in
the hierarchy integer < double < character.
For \code{min} and \code{max} if there are only numeric inputs and all
are empty (after possible removal of \code{NA}s), the result is double
(\code{Inf} or \code{-Inf}).
}
\section{S4 methods}{
\code{max} and \code{min} are part of the S4
\code{\link[=S4groupGeneric]{Summary}} group generic. Methods
for them must use the signature \code{x, \dots, na.rm}.
}
\references{
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
\emph{The New S Language}.
Wadsworth & Brooks/Cole.
}
\note{
\sQuote{Numeric} arguments are vectors of type integer and numeric,
and logical (coerced to integer). For historical reasons, \code{NULL}
is accepted as equivalent to \code{integer(0)}.% PR#1283
\code{pmax} and \code{pmin} will also work on classed objects with
appropriate methods for comparison, \code{is.na} and \code{rep} (if
recycling of arguments is needed).
}
\seealso{
\code{\link{range}} (\emph{both} min and max) and
\code{\link{which.min}} (\code{which.max}) for the \emph{arg min},
i.e., the location where an extreme value occurs.
\sQuote{\link{plotmath}} for the use of \code{min} in plot annotation.
}
\examples{
require(stats); require(graphics)
min(5:1, pi) #-> one number
pmin(5:1, pi) #-> 5 numbers
x <- sort(rnorm(100)); cH <- 1.35
pmin(cH, quantile(x)) # no names
pmin(quantile(x), cH) # has names
plot(x, pmin(cH, pmax(-cH, x)), type = "b", main = "Huber's function")
cut01 <- function(x) pmax(pmin(x, 1), 0)
curve( x^2 - 1/4, -1.4, 1.5, col = 2)
curve(cut01(x^2 - 1/4), col = "blue", add = TRUE, n = 500)
## pmax(), pmin() preserve attributes of *first* argument
D <- diag(x = (3:1)/4) ; n0 <- numeric()
stopifnot(identical(D, cut01(D) ),
identical(n0, cut01(n0)),
identical(n0, cut01(NULL)),
identical(n0, pmax(3:1, n0, 2)),
identical(n0, pmax(n0, 4)))
}
\keyword{univar}
\keyword{arith}
| 5,740 | gpl-2.0 |
466e22f331fdd1a03a121c8a4aa8ff63c1003ba7 | skyguy94/R | src/library/base/man/Extremes.Rd | % File src/library/base/man/Extremes.Rd
% Part of the R package, http://www.R-project.org
% Copyright 1995-2013 R Core Team
% Distributed under GPL 2 or later
\name{Extremes}
\alias{max}
\alias{min}
\alias{pmax}
\alias{pmin}
\alias{pmax.int}
\alias{pmin.int}
\title{Maxima and Minima}
\description{
Returns the (parallel) maxima and minima of the input values.
}
\usage{
max(\dots, na.rm = FALSE)
min(\dots, na.rm = FALSE)
pmax(\dots, na.rm = FALSE)
pmin(\dots, na.rm = FALSE)
pmax.int(\dots, na.rm = FALSE)
pmin.int(\dots, na.rm = FALSE)
}
\arguments{
\item{\dots}{numeric or character arguments (see Note).}
\item{na.rm}{a logical indicating whether missing values should be
removed.}
}
\details{
\code{max} and \code{min} return the maximum or minimum of \emph{all}
the values present in their arguments, as \code{\link{integer}} if
all are \code{logical} or \code{integer}, as \code{\link{double}} if
all are numeric, and character otherwise.
If \code{na.rm} is \code{FALSE} an \code{NA} value in any of the
arguments will cause a value of \code{NA} to be returned, otherwise
\code{NA} values are ignored.
The minimum and maximum of a numeric empty set are \code{+Inf} and
\code{-Inf} (in this order!) which ensures \emph{transitivity}, e.g.,
\code{min(x1, min(x2)) == min(x1, x2)}. For numeric \code{x}
\code{max(x) == -Inf} and \code{min(x) == +Inf}
whenever \code{length(x) == 0} (after removing missing values if
requested). However, \code{pmax} and \code{pmin} return
\code{NA} if all the parallel elements are \code{NA} even for
\code{na.rm = TRUE}.
\code{pmax} and \code{pmin} take one or more vectors (or matrices) as
arguments and return a single vector giving the \sQuote{parallel}
maxima (or minima) of the vectors. The first element of the result is
the maximum (minimum) of the first elements of all the arguments, the
second element of the result is the maximum (minimum) of the second
elements of all the arguments and so on. Shorter inputs (of non-zero
length) are recycled if necessary. Attributes (see
\code{\link{attributes}}: such as \code{\link{names}} or
\code{\link{dim}}) are copied from the first argument (if applicable).
\code{pmax.int} and \code{pmin.int} are faster internal versions only
used when all arguments are atomic vectors and there are no classes:
they drop all attributes. (Note that all versions fail for raw and
complex vectors since these have no ordering.)
\code{max} and \code{min} are generic functions: methods can be
defined for them individually or via the
\code{\link[=S3groupGeneric]{Summary}} group generic. For this to
work properly, the arguments \code{\dots} should be unnamed, and
dispatch is on the first argument.
By definition the min/max of a numeric vector containing an \code{NaN}
is \code{NaN}, except that the min/max of any vector containing an
\code{NA} is \code{NA} even if it also contains an \code{NaN}.
Note that \code{max(NA, Inf) == NA} even though the maximum would be
\code{Inf} whatever the missing value actually is.
Character versions are sorted lexicographically, and this depends on
the collating sequence of the locale in use: the help for
\sQuote{\link{Comparison}} gives details. The max/min of an empty
character vector is defined to be character \code{NA}. (One could
argue that as \code{""} is the smallest character element, the maximum
should be \code{""}, but there is no obvious candidate for the
minimum.)
}
\value{
For \code{min} or \code{max}, a length-one vector. For \code{pmin} or
\code{pmax}, a vector of length the longest of the input vectors, or
length zero if one of the inputs had zero length.
The type of the result will be that of the highest of the inputs in
the hierarchy integer < double < character.
For \code{min} and \code{max} if there are only numeric inputs and all
are empty (after possible removal of \code{NA}s), the result is double
(\code{Inf} or \code{-Inf}).
}
\section{S4 methods}{
\code{max} and \code{min} are part of the S4
\code{\link[=S4groupGeneric]{Summary}} group generic. Methods
for them must use the signature \code{x, \dots, na.rm}.
}
\references{
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
\emph{The New S Language}.
Wadsworth & Brooks/Cole.
}
\note{
\sQuote{Numeric} arguments are vectors of type integer and numeric,
and logical (coerced to integer). For historical reasons, \code{NULL}
is accepted as equivalent to \code{integer(0)}.% PR#1283
\code{pmax} and \code{pmin} will also work on classed objects with
appropriate methods for comparison, \code{is.na} and \code{rep} (if
recycling of arguments is needed).
}
\seealso{
\code{\link{range}} (\emph{both} min and max) and
\code{\link{which.min}} (\code{which.max}) for the \emph{arg min},
i.e., the location where an extreme value occurs.
\sQuote{\link{plotmath}} for the use of \code{min} in plot annotation.
}
\examples{
require(stats); require(graphics)
min(5:1, pi) #-> one number
pmin(5:1, pi) #-> 5 numbers
x <- sort(rnorm(100)); cH <- 1.35
pmin(cH, quantile(x)) # no names
pmin(quantile(x), cH) # has names
plot(x, pmin(cH, pmax(-cH, x)), type = "b", main = "Huber's function")
cut01 <- function(x) pmax(pmin(x, 1), 0)
curve( x^2 - 1/4, -1.4, 1.5, col = 2)
curve(cut01(x^2 - 1/4), col = "blue", add = TRUE, n = 500)
## pmax(), pmin() preserve attributes of *first* argument
D <- diag(x = (3:1)/4) ; n0 <- numeric()
stopifnot(identical(D, cut01(D) ),
identical(n0, cut01(n0)),
identical(n0, cut01(NULL)),
identical(n0, pmax(3:1, n0, 2)),
identical(n0, pmax(n0, 4)))
}
\keyword{univar}
\keyword{arith}
| 5,740 | gpl-2.0 |
466e22f331fdd1a03a121c8a4aa8ff63c1003ba7 | jeffreyhorner/R-Array-Hash | src/library/base/man/Extremes.Rd | % File src/library/base/man/Extremes.Rd
% Part of the R package, http://www.R-project.org
% Copyright 1995-2013 R Core Team
% Distributed under GPL 2 or later
\name{Extremes}
\alias{max}
\alias{min}
\alias{pmax}
\alias{pmin}
\alias{pmax.int}
\alias{pmin.int}
\title{Maxima and Minima}
\description{
Returns the (parallel) maxima and minima of the input values.
}
\usage{
max(\dots, na.rm = FALSE)
min(\dots, na.rm = FALSE)
pmax(\dots, na.rm = FALSE)
pmin(\dots, na.rm = FALSE)
pmax.int(\dots, na.rm = FALSE)
pmin.int(\dots, na.rm = FALSE)
}
\arguments{
\item{\dots}{numeric or character arguments (see Note).}
\item{na.rm}{a logical indicating whether missing values should be
removed.}
}
\details{
\code{max} and \code{min} return the maximum or minimum of \emph{all}
the values present in their arguments, as \code{\link{integer}} if
all are \code{logical} or \code{integer}, as \code{\link{double}} if
all are numeric, and character otherwise.
If \code{na.rm} is \code{FALSE} an \code{NA} value in any of the
arguments will cause a value of \code{NA} to be returned, otherwise
\code{NA} values are ignored.
The minimum and maximum of a numeric empty set are \code{+Inf} and
\code{-Inf} (in this order!) which ensures \emph{transitivity}, e.g.,
\code{min(x1, min(x2)) == min(x1, x2)}. For numeric \code{x}
\code{max(x) == -Inf} and \code{min(x) == +Inf}
whenever \code{length(x) == 0} (after removing missing values if
requested). However, \code{pmax} and \code{pmin} return
\code{NA} if all the parallel elements are \code{NA} even for
\code{na.rm = TRUE}.
\code{pmax} and \code{pmin} take one or more vectors (or matrices) as
arguments and return a single vector giving the \sQuote{parallel}
maxima (or minima) of the vectors. The first element of the result is
the maximum (minimum) of the first elements of all the arguments, the
second element of the result is the maximum (minimum) of the second
elements of all the arguments and so on. Shorter inputs (of non-zero
length) are recycled if necessary. Attributes (see
\code{\link{attributes}}: such as \code{\link{names}} or
\code{\link{dim}}) are copied from the first argument (if applicable).
\code{pmax.int} and \code{pmin.int} are faster internal versions only
used when all arguments are atomic vectors and there are no classes:
they drop all attributes. (Note that all versions fail for raw and
complex vectors since these have no ordering.)
\code{max} and \code{min} are generic functions: methods can be
defined for them individually or via the
\code{\link[=S3groupGeneric]{Summary}} group generic. For this to
work properly, the arguments \code{\dots} should be unnamed, and
dispatch is on the first argument.
By definition the min/max of a numeric vector containing an \code{NaN}
is \code{NaN}, except that the min/max of any vector containing an
\code{NA} is \code{NA} even if it also contains an \code{NaN}.
Note that \code{max(NA, Inf) == NA} even though the maximum would be
\code{Inf} whatever the missing value actually is.
Character versions are sorted lexicographically, and this depends on
the collating sequence of the locale in use: the help for
\sQuote{\link{Comparison}} gives details. The max/min of an empty
character vector is defined to be character \code{NA}. (One could
argue that as \code{""} is the smallest character element, the maximum
should be \code{""}, but there is no obvious candidate for the
minimum.)
}
\value{
For \code{min} or \code{max}, a length-one vector. For \code{pmin} or
\code{pmax}, a vector of length the longest of the input vectors, or
length zero if one of the inputs had zero length.
The type of the result will be that of the highest of the inputs in
the hierarchy integer < double < character.
For \code{min} and \code{max} if there are only numeric inputs and all
are empty (after possible removal of \code{NA}s), the result is double
(\code{Inf} or \code{-Inf}).
}
\section{S4 methods}{
\code{max} and \code{min} are part of the S4
\code{\link[=S4groupGeneric]{Summary}} group generic. Methods
for them must use the signature \code{x, \dots, na.rm}.
}
\references{
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
\emph{The New S Language}.
Wadsworth & Brooks/Cole.
}
\note{
\sQuote{Numeric} arguments are vectors of type integer and numeric,
and logical (coerced to integer). For historical reasons, \code{NULL}
is accepted as equivalent to \code{integer(0)}.% PR#1283
\code{pmax} and \code{pmin} will also work on classed objects with
appropriate methods for comparison, \code{is.na} and \code{rep} (if
recycling of arguments is needed).
}
\seealso{
\code{\link{range}} (\emph{both} min and max) and
\code{\link{which.min}} (\code{which.max}) for the \emph{arg min},
i.e., the location where an extreme value occurs.
\sQuote{\link{plotmath}} for the use of \code{min} in plot annotation.
}
\examples{
require(stats); require(graphics)
min(5:1, pi) #-> one number
pmin(5:1, pi) #-> 5 numbers
x <- sort(rnorm(100)); cH <- 1.35
pmin(cH, quantile(x)) # no names
pmin(quantile(x), cH) # has names
plot(x, pmin(cH, pmax(-cH, x)), type = "b", main = "Huber's function")
cut01 <- function(x) pmax(pmin(x, 1), 0)
curve( x^2 - 1/4, -1.4, 1.5, col = 2)
curve(cut01(x^2 - 1/4), col = "blue", add = TRUE, n = 500)
## pmax(), pmin() preserve attributes of *first* argument
D <- diag(x = (3:1)/4) ; n0 <- numeric()
stopifnot(identical(D, cut01(D) ),
identical(n0, cut01(n0)),
identical(n0, cut01(NULL)),
identical(n0, pmax(3:1, n0, 2)),
identical(n0, pmax(n0, 4)))
}
\keyword{univar}
\keyword{arith}
| 5,740 | gpl-2.0 |
466e22f331fdd1a03a121c8a4aa8ff63c1003ba7 | kalibera/rexp | src/library/base/man/Extremes.Rd | % File src/library/base/man/Extremes.Rd
% Part of the R package, http://www.R-project.org
% Copyright 1995-2013 R Core Team
% Distributed under GPL 2 or later
\name{Extremes}
\alias{max}
\alias{min}
\alias{pmax}
\alias{pmin}
\alias{pmax.int}
\alias{pmin.int}
\title{Maxima and Minima}
\description{
Returns the (parallel) maxima and minima of the input values.
}
\usage{
max(\dots, na.rm = FALSE)
min(\dots, na.rm = FALSE)
pmax(\dots, na.rm = FALSE)
pmin(\dots, na.rm = FALSE)
pmax.int(\dots, na.rm = FALSE)
pmin.int(\dots, na.rm = FALSE)
}
\arguments{
\item{\dots}{numeric or character arguments (see Note).}
\item{na.rm}{a logical indicating whether missing values should be
removed.}
}
\details{
\code{max} and \code{min} return the maximum or minimum of \emph{all}
the values present in their arguments, as \code{\link{integer}} if
all are \code{logical} or \code{integer}, as \code{\link{double}} if
all are numeric, and character otherwise.
If \code{na.rm} is \code{FALSE} an \code{NA} value in any of the
arguments will cause a value of \code{NA} to be returned, otherwise
\code{NA} values are ignored.
The minimum and maximum of a numeric empty set are \code{+Inf} and
\code{-Inf} (in this order!) which ensures \emph{transitivity}, e.g.,
\code{min(x1, min(x2)) == min(x1, x2)}. For numeric \code{x}
\code{max(x) == -Inf} and \code{min(x) == +Inf}
whenever \code{length(x) == 0} (after removing missing values if
requested). However, \code{pmax} and \code{pmin} return
\code{NA} if all the parallel elements are \code{NA} even for
\code{na.rm = TRUE}.
\code{pmax} and \code{pmin} take one or more vectors (or matrices) as
arguments and return a single vector giving the \sQuote{parallel}
maxima (or minima) of the vectors. The first element of the result is
the maximum (minimum) of the first elements of all the arguments, the
second element of the result is the maximum (minimum) of the second
elements of all the arguments and so on. Shorter inputs (of non-zero
length) are recycled if necessary. Attributes (see
\code{\link{attributes}}: such as \code{\link{names}} or
\code{\link{dim}}) are copied from the first argument (if applicable).
\code{pmax.int} and \code{pmin.int} are faster internal versions only
used when all arguments are atomic vectors and there are no classes:
they drop all attributes. (Note that all versions fail for raw and
complex vectors since these have no ordering.)
\code{max} and \code{min} are generic functions: methods can be
defined for them individually or via the
\code{\link[=S3groupGeneric]{Summary}} group generic. For this to
work properly, the arguments \code{\dots} should be unnamed, and
dispatch is on the first argument.
By definition the min/max of a numeric vector containing an \code{NaN}
is \code{NaN}, except that the min/max of any vector containing an
\code{NA} is \code{NA} even if it also contains an \code{NaN}.
Note that \code{max(NA, Inf) == NA} even though the maximum would be
\code{Inf} whatever the missing value actually is.
Character versions are sorted lexicographically, and this depends on
the collating sequence of the locale in use: the help for
\sQuote{\link{Comparison}} gives details. The max/min of an empty
character vector is defined to be character \code{NA}. (One could
argue that as \code{""} is the smallest character element, the maximum
should be \code{""}, but there is no obvious candidate for the
minimum.)
}
\value{
For \code{min} or \code{max}, a length-one vector. For \code{pmin} or
\code{pmax}, a vector of length the longest of the input vectors, or
length zero if one of the inputs had zero length.
The type of the result will be that of the highest of the inputs in
the hierarchy integer < double < character.
For \code{min} and \code{max} if there are only numeric inputs and all
are empty (after possible removal of \code{NA}s), the result is double
(\code{Inf} or \code{-Inf}).
}
\section{S4 methods}{
\code{max} and \code{min} are part of the S4
\code{\link[=S4groupGeneric]{Summary}} group generic. Methods
for them must use the signature \code{x, \dots, na.rm}.
}
\references{
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
\emph{The New S Language}.
Wadsworth & Brooks/Cole.
}
\note{
\sQuote{Numeric} arguments are vectors of type integer and numeric,
and logical (coerced to integer). For historical reasons, \code{NULL}
is accepted as equivalent to \code{integer(0)}.% PR#1283
\code{pmax} and \code{pmin} will also work on classed objects with
appropriate methods for comparison, \code{is.na} and \code{rep} (if
recycling of arguments is needed).
}
\seealso{
\code{\link{range}} (\emph{both} min and max) and
\code{\link{which.min}} (\code{which.max}) for the \emph{arg min},
i.e., the location where an extreme value occurs.
\sQuote{\link{plotmath}} for the use of \code{min} in plot annotation.
}
\examples{
require(stats); require(graphics)
min(5:1, pi) #-> one number
pmin(5:1, pi) #-> 5 numbers
x <- sort(rnorm(100)); cH <- 1.35
pmin(cH, quantile(x)) # no names
pmin(quantile(x), cH) # has names
plot(x, pmin(cH, pmax(-cH, x)), type = "b", main = "Huber's function")
cut01 <- function(x) pmax(pmin(x, 1), 0)
curve( x^2 - 1/4, -1.4, 1.5, col = 2)
curve(cut01(x^2 - 1/4), col = "blue", add = TRUE, n = 500)
## pmax(), pmin() preserve attributes of *first* argument
D <- diag(x = (3:1)/4) ; n0 <- numeric()
stopifnot(identical(D, cut01(D) ),
identical(n0, cut01(n0)),
identical(n0, cut01(NULL)),
identical(n0, pmax(3:1, n0, 2)),
identical(n0, pmax(n0, 4)))
}
\keyword{univar}
\keyword{arith}
| 5,740 | gpl-2.0 |
466e22f331fdd1a03a121c8a4aa8ff63c1003ba7 | jagdeesh109/RRO | R-src/src/library/base/man/Extremes.Rd | % File src/library/base/man/Extremes.Rd
% Part of the R package, http://www.R-project.org
% Copyright 1995-2013 R Core Team
% Distributed under GPL 2 or later
\name{Extremes}
\alias{max}
\alias{min}
\alias{pmax}
\alias{pmin}
\alias{pmax.int}
\alias{pmin.int}
\title{Maxima and Minima}
\description{
Returns the (parallel) maxima and minima of the input values.
}
\usage{
max(\dots, na.rm = FALSE)
min(\dots, na.rm = FALSE)
pmax(\dots, na.rm = FALSE)
pmin(\dots, na.rm = FALSE)
pmax.int(\dots, na.rm = FALSE)
pmin.int(\dots, na.rm = FALSE)
}
\arguments{
\item{\dots}{numeric or character arguments (see Note).}
\item{na.rm}{a logical indicating whether missing values should be
removed.}
}
\details{
\code{max} and \code{min} return the maximum or minimum of \emph{all}
the values present in their arguments, as \code{\link{integer}} if
all are \code{logical} or \code{integer}, as \code{\link{double}} if
all are numeric, and character otherwise.
If \code{na.rm} is \code{FALSE} an \code{NA} value in any of the
arguments will cause a value of \code{NA} to be returned, otherwise
\code{NA} values are ignored.
The minimum and maximum of a numeric empty set are \code{+Inf} and
\code{-Inf} (in this order!) which ensures \emph{transitivity}, e.g.,
\code{min(x1, min(x2)) == min(x1, x2)}. For numeric \code{x}
\code{max(x) == -Inf} and \code{min(x) == +Inf}
whenever \code{length(x) == 0} (after removing missing values if
requested). However, \code{pmax} and \code{pmin} return
\code{NA} if all the parallel elements are \code{NA} even for
\code{na.rm = TRUE}.
\code{pmax} and \code{pmin} take one or more vectors (or matrices) as
arguments and return a single vector giving the \sQuote{parallel}
maxima (or minima) of the vectors. The first element of the result is
the maximum (minimum) of the first elements of all the arguments, the
second element of the result is the maximum (minimum) of the second
elements of all the arguments and so on. Shorter inputs (of non-zero
length) are recycled if necessary. Attributes (see
\code{\link{attributes}}: such as \code{\link{names}} or
\code{\link{dim}}) are copied from the first argument (if applicable).
\code{pmax.int} and \code{pmin.int} are faster internal versions only
used when all arguments are atomic vectors and there are no classes:
they drop all attributes. (Note that all versions fail for raw and
complex vectors since these have no ordering.)
\code{max} and \code{min} are generic functions: methods can be
defined for them individually or via the
\code{\link[=S3groupGeneric]{Summary}} group generic. For this to
work properly, the arguments \code{\dots} should be unnamed, and
dispatch is on the first argument.
By definition the min/max of a numeric vector containing an \code{NaN}
is \code{NaN}, except that the min/max of any vector containing an
\code{NA} is \code{NA} even if it also contains an \code{NaN}.
Note that \code{max(NA, Inf) == NA} even though the maximum would be
\code{Inf} whatever the missing value actually is.
Character versions are sorted lexicographically, and this depends on
the collating sequence of the locale in use: the help for
\sQuote{\link{Comparison}} gives details. The max/min of an empty
character vector is defined to be character \code{NA}. (One could
argue that as \code{""} is the smallest character element, the maximum
should be \code{""}, but there is no obvious candidate for the
minimum.)
}
\value{
For \code{min} or \code{max}, a length-one vector. For \code{pmin} or
\code{pmax}, a vector of length the longest of the input vectors, or
length zero if one of the inputs had zero length.
The type of the result will be that of the highest of the inputs in
the hierarchy integer < double < character.
For \code{min} and \code{max} if there are only numeric inputs and all
are empty (after possible removal of \code{NA}s), the result is double
(\code{Inf} or \code{-Inf}).
}
\section{S4 methods}{
\code{max} and \code{min} are part of the S4
\code{\link[=S4groupGeneric]{Summary}} group generic. Methods
for them must use the signature \code{x, \dots, na.rm}.
}
\references{
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
\emph{The New S Language}.
Wadsworth & Brooks/Cole.
}
\note{
\sQuote{Numeric} arguments are vectors of type integer and numeric,
and logical (coerced to integer). For historical reasons, \code{NULL}
is accepted as equivalent to \code{integer(0)}.% PR#1283
\code{pmax} and \code{pmin} will also work on classed objects with
appropriate methods for comparison, \code{is.na} and \code{rep} (if
recycling of arguments is needed).
}
\seealso{
\code{\link{range}} (\emph{both} min and max) and
\code{\link{which.min}} (\code{which.max}) for the \emph{arg min},
i.e., the location where an extreme value occurs.
\sQuote{\link{plotmath}} for the use of \code{min} in plot annotation.
}
\examples{
require(stats); require(graphics)
min(5:1, pi) #-> one number
pmin(5:1, pi) #-> 5 numbers
x <- sort(rnorm(100)); cH <- 1.35
pmin(cH, quantile(x)) # no names
pmin(quantile(x), cH) # has names
plot(x, pmin(cH, pmax(-cH, x)), type = "b", main = "Huber's function")
cut01 <- function(x) pmax(pmin(x, 1), 0)
curve( x^2 - 1/4, -1.4, 1.5, col = 2)
curve(cut01(x^2 - 1/4), col = "blue", add = TRUE, n = 500)
## pmax(), pmin() preserve attributes of *first* argument
D <- diag(x = (3:1)/4) ; n0 <- numeric()
stopifnot(identical(D, cut01(D) ),
identical(n0, cut01(n0)),
identical(n0, cut01(NULL)),
identical(n0, pmax(3:1, n0, 2)),
identical(n0, pmax(n0, 4)))
}
\keyword{univar}
\keyword{arith}
| 5,740 | gpl-2.0 |
466e22f331fdd1a03a121c8a4aa8ff63c1003ba7 | lajus/customr | src/library/base/man/Extremes.Rd | % File src/library/base/man/Extremes.Rd
% Part of the R package, http://www.R-project.org
% Copyright 1995-2013 R Core Team
% Distributed under GPL 2 or later
\name{Extremes}
\alias{max}
\alias{min}
\alias{pmax}
\alias{pmin}
\alias{pmax.int}
\alias{pmin.int}
\title{Maxima and Minima}
\description{
Returns the (parallel) maxima and minima of the input values.
}
\usage{
max(\dots, na.rm = FALSE)
min(\dots, na.rm = FALSE)
pmax(\dots, na.rm = FALSE)
pmin(\dots, na.rm = FALSE)
pmax.int(\dots, na.rm = FALSE)
pmin.int(\dots, na.rm = FALSE)
}
\arguments{
\item{\dots}{numeric or character arguments (see Note).}
\item{na.rm}{a logical indicating whether missing values should be
removed.}
}
\details{
\code{max} and \code{min} return the maximum or minimum of \emph{all}
the values present in their arguments, as \code{\link{integer}} if
all are \code{logical} or \code{integer}, as \code{\link{double}} if
all are numeric, and character otherwise.
If \code{na.rm} is \code{FALSE} an \code{NA} value in any of the
arguments will cause a value of \code{NA} to be returned, otherwise
\code{NA} values are ignored.
The minimum and maximum of a numeric empty set are \code{+Inf} and
\code{-Inf} (in this order!) which ensures \emph{transitivity}, e.g.,
\code{min(x1, min(x2)) == min(x1, x2)}. For numeric \code{x}
\code{max(x) == -Inf} and \code{min(x) == +Inf}
whenever \code{length(x) == 0} (after removing missing values if
requested). However, \code{pmax} and \code{pmin} return
\code{NA} if all the parallel elements are \code{NA} even for
\code{na.rm = TRUE}.
\code{pmax} and \code{pmin} take one or more vectors (or matrices) as
arguments and return a single vector giving the \sQuote{parallel}
maxima (or minima) of the vectors. The first element of the result is
the maximum (minimum) of the first elements of all the arguments, the
second element of the result is the maximum (minimum) of the second
elements of all the arguments and so on. Shorter inputs (of non-zero
length) are recycled if necessary. Attributes (see
\code{\link{attributes}}: such as \code{\link{names}} or
\code{\link{dim}}) are copied from the first argument (if applicable).
\code{pmax.int} and \code{pmin.int} are faster internal versions only
used when all arguments are atomic vectors and there are no classes:
they drop all attributes. (Note that all versions fail for raw and
complex vectors since these have no ordering.)
\code{max} and \code{min} are generic functions: methods can be
defined for them individually or via the
\code{\link[=S3groupGeneric]{Summary}} group generic. For this to
work properly, the arguments \code{\dots} should be unnamed, and
dispatch is on the first argument.
By definition the min/max of a numeric vector containing an \code{NaN}
is \code{NaN}, except that the min/max of any vector containing an
\code{NA} is \code{NA} even if it also contains an \code{NaN}.
Note that \code{max(NA, Inf) == NA} even though the maximum would be
\code{Inf} whatever the missing value actually is.
Character versions are sorted lexicographically, and this depends on
the collating sequence of the locale in use: the help for
\sQuote{\link{Comparison}} gives details. The max/min of an empty
character vector is defined to be character \code{NA}. (One could
argue that as \code{""} is the smallest character element, the maximum
should be \code{""}, but there is no obvious candidate for the
minimum.)
}
\value{
For \code{min} or \code{max}, a length-one vector. For \code{pmin} or
\code{pmax}, a vector of length the longest of the input vectors, or
length zero if one of the inputs had zero length.
The type of the result will be that of the highest of the inputs in
the hierarchy integer < double < character.
For \code{min} and \code{max} if there are only numeric inputs and all
are empty (after possible removal of \code{NA}s), the result is double
(\code{Inf} or \code{-Inf}).
}
\section{S4 methods}{
\code{max} and \code{min} are part of the S4
\code{\link[=S4groupGeneric]{Summary}} group generic. Methods
for them must use the signature \code{x, \dots, na.rm}.
}
\references{
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
\emph{The New S Language}.
Wadsworth & Brooks/Cole.
}
\note{
\sQuote{Numeric} arguments are vectors of type integer and numeric,
and logical (coerced to integer). For historical reasons, \code{NULL}
is accepted as equivalent to \code{integer(0)}.% PR#1283
\code{pmax} and \code{pmin} will also work on classed objects with
appropriate methods for comparison, \code{is.na} and \code{rep} (if
recycling of arguments is needed).
}
\seealso{
\code{\link{range}} (\emph{both} min and max) and
\code{\link{which.min}} (\code{which.max}) for the \emph{arg min},
i.e., the location where an extreme value occurs.
\sQuote{\link{plotmath}} for the use of \code{min} in plot annotation.
}
\examples{
require(stats); require(graphics)
min(5:1, pi) #-> one number
pmin(5:1, pi) #-> 5 numbers
x <- sort(rnorm(100)); cH <- 1.35
pmin(cH, quantile(x)) # no names
pmin(quantile(x), cH) # has names
plot(x, pmin(cH, pmax(-cH, x)), type = "b", main = "Huber's function")
cut01 <- function(x) pmax(pmin(x, 1), 0)
curve( x^2 - 1/4, -1.4, 1.5, col = 2)
curve(cut01(x^2 - 1/4), col = "blue", add = TRUE, n = 500)
## pmax(), pmin() preserve attributes of *first* argument
D <- diag(x = (3:1)/4) ; n0 <- numeric()
stopifnot(identical(D, cut01(D) ),
identical(n0, cut01(n0)),
identical(n0, cut01(NULL)),
identical(n0, pmax(3:1, n0, 2)),
identical(n0, pmax(n0, 4)))
}
\keyword{univar}
\keyword{arith}
| 5,740 | gpl-2.0 |
466e22f331fdd1a03a121c8a4aa8ff63c1003ba7 | o-/Rexperiments | src/library/base/man/Extremes.Rd | % File src/library/base/man/Extremes.Rd
% Part of the R package, http://www.R-project.org
% Copyright 1995-2013 R Core Team
% Distributed under GPL 2 or later
\name{Extremes}
\alias{max}
\alias{min}
\alias{pmax}
\alias{pmin}
\alias{pmax.int}
\alias{pmin.int}
\title{Maxima and Minima}
\description{
Returns the (parallel) maxima and minima of the input values.
}
\usage{
max(\dots, na.rm = FALSE)
min(\dots, na.rm = FALSE)
pmax(\dots, na.rm = FALSE)
pmin(\dots, na.rm = FALSE)
pmax.int(\dots, na.rm = FALSE)
pmin.int(\dots, na.rm = FALSE)
}
\arguments{
\item{\dots}{numeric or character arguments (see Note).}
\item{na.rm}{a logical indicating whether missing values should be
removed.}
}
\details{
\code{max} and \code{min} return the maximum or minimum of \emph{all}
the values present in their arguments, as \code{\link{integer}} if
all are \code{logical} or \code{integer}, as \code{\link{double}} if
all are numeric, and character otherwise.
If \code{na.rm} is \code{FALSE} an \code{NA} value in any of the
arguments will cause a value of \code{NA} to be returned, otherwise
\code{NA} values are ignored.
The minimum and maximum of a numeric empty set are \code{+Inf} and
\code{-Inf} (in this order!) which ensures \emph{transitivity}, e.g.,
\code{min(x1, min(x2)) == min(x1, x2)}. For numeric \code{x}
\code{max(x) == -Inf} and \code{min(x) == +Inf}
whenever \code{length(x) == 0} (after removing missing values if
requested). However, \code{pmax} and \code{pmin} return
\code{NA} if all the parallel elements are \code{NA} even for
\code{na.rm = TRUE}.
\code{pmax} and \code{pmin} take one or more vectors (or matrices) as
arguments and return a single vector giving the \sQuote{parallel}
maxima (or minima) of the vectors. The first element of the result is
the maximum (minimum) of the first elements of all the arguments, the
second element of the result is the maximum (minimum) of the second
elements of all the arguments and so on. Shorter inputs (of non-zero
length) are recycled if necessary. Attributes (see
\code{\link{attributes}}: such as \code{\link{names}} or
\code{\link{dim}}) are copied from the first argument (if applicable).
\code{pmax.int} and \code{pmin.int} are faster internal versions only
used when all arguments are atomic vectors and there are no classes:
they drop all attributes. (Note that all versions fail for raw and
complex vectors since these have no ordering.)
\code{max} and \code{min} are generic functions: methods can be
defined for them individually or via the
\code{\link[=S3groupGeneric]{Summary}} group generic. For this to
work properly, the arguments \code{\dots} should be unnamed, and
dispatch is on the first argument.
By definition the min/max of a numeric vector containing an \code{NaN}
is \code{NaN}, except that the min/max of any vector containing an
\code{NA} is \code{NA} even if it also contains an \code{NaN}.
Note that \code{max(NA, Inf) == NA} even though the maximum would be
\code{Inf} whatever the missing value actually is.
Character versions are sorted lexicographically, and this depends on
the collating sequence of the locale in use: the help for
\sQuote{\link{Comparison}} gives details. The max/min of an empty
character vector is defined to be character \code{NA}. (One could
argue that as \code{""} is the smallest character element, the maximum
should be \code{""}, but there is no obvious candidate for the
minimum.)
}
\value{
For \code{min} or \code{max}, a length-one vector. For \code{pmin} or
\code{pmax}, a vector of length the longest of the input vectors, or
length zero if one of the inputs had zero length.
The type of the result will be that of the highest of the inputs in
the hierarchy integer < double < character.
For \code{min} and \code{max} if there are only numeric inputs and all
are empty (after possible removal of \code{NA}s), the result is double
(\code{Inf} or \code{-Inf}).
}
\section{S4 methods}{
\code{max} and \code{min} are part of the S4
\code{\link[=S4groupGeneric]{Summary}} group generic. Methods
for them must use the signature \code{x, \dots, na.rm}.
}
\references{
Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988)
\emph{The New S Language}.
Wadsworth & Brooks/Cole.
}
\note{
\sQuote{Numeric} arguments are vectors of type integer and numeric,
and logical (coerced to integer). For historical reasons, \code{NULL}
is accepted as equivalent to \code{integer(0)}.% PR#1283
\code{pmax} and \code{pmin} will also work on classed objects with
appropriate methods for comparison, \code{is.na} and \code{rep} (if
recycling of arguments is needed).
}
\seealso{
\code{\link{range}} (\emph{both} min and max) and
\code{\link{which.min}} (\code{which.max}) for the \emph{arg min},
i.e., the location where an extreme value occurs.
\sQuote{\link{plotmath}} for the use of \code{min} in plot annotation.
}
\examples{
require(stats); require(graphics)
min(5:1, pi) #-> one number
pmin(5:1, pi) #-> 5 numbers
x <- sort(rnorm(100)); cH <- 1.35
pmin(cH, quantile(x)) # no names
pmin(quantile(x), cH) # has names
plot(x, pmin(cH, pmax(-cH, x)), type = "b", main = "Huber's function")
cut01 <- function(x) pmax(pmin(x, 1), 0)
curve( x^2 - 1/4, -1.4, 1.5, col = 2)
curve(cut01(x^2 - 1/4), col = "blue", add = TRUE, n = 500)
## pmax(), pmin() preserve attributes of *first* argument
D <- diag(x = (3:1)/4) ; n0 <- numeric()
stopifnot(identical(D, cut01(D) ),
identical(n0, cut01(n0)),
identical(n0, cut01(NULL)),
identical(n0, pmax(3:1, n0, 2)),
identical(n0, pmax(n0, 4)))
}
\keyword{univar}
\keyword{arith}
| 5,740 | gpl-2.0 |