From 5e2b7ad7cc5a3b60049f89196a9fb58db6433dd7 Mon Sep 17 00:00:00 2001 From: Deyu Ming Date: Thu, 12 Dec 2024 22:04:25 +0000 Subject: [PATCH] Doc updates Doc updates with status labels --- R/alm.R | 10 +++++++--- R/design.R | 12 ++++++++---- R/draw.R | 8 ++++++-- R/lgp.R | 6 +++++- R/mice.R | 10 +++++++--- R/plot.R | 8 ++++++-- R/prediction.R | 7 +++++-- R/serialization.R | 12 ++++++++++-- R/vigf.R | 12 ++++++++---- man/alm.Rd | 6 ++++-- man/deserialize.Rd | 2 ++ man/design.Rd | 8 +++++--- man/draw.Rd | 4 +++- man/lgp.Rd | 2 ++ man/mice.Rd | 6 ++++-- man/plot.Rd | 4 +++- man/predict.Rd | 5 +++-- man/serialize.Rd | 2 ++ man/vigf.Rd | 8 +++++--- 19 files changed, 95 insertions(+), 37 deletions(-) diff --git a/R/alm.R b/R/alm.R index 3f3878f..6f1ce6a 100644 --- a/R/alm.R +++ b/R/alm.R @@ -1,6 +1,10 @@ #' @title Locate the next design point(s) for a (D)GP emulator or a bundle of (D)GP emulators using Active Learning MacKay (ALM) #' -#' @description This function searches from a candidate set to locate the next design point(s) to be added to a (D)GP emulator +#' @description +#' +#' `r new_badge("updated")` +#' +#' This function searches from a candidate set to locate the next design point(s) to be added to a (D)GP emulator #' or a bundle of (D)GP emulators using the Active Learning MacKay (ALM) criterion (see the reference below). #' #' @param object can be one of the following: @@ -11,7 +15,7 @@ #' from which the next design point(s) are determined. If `object` is an instance of the `bundle` class and `aggregate` is not supplied, `x_cand` can also be a list. #' The list must have a length equal to the number of emulators in `object`, with each element being a matrix representing the candidate set for a corresponding #' emulator in the bundle. Defaults to `NULL`. -#' @param n_start an integer that gives the number of initial design points to be used to determine next design point(s). This argument +#' @param n_start `r new_badge("new")` an integer that gives the number of initial design points to be used to determine next design point(s). This argument #' is only used when `x_cand` is `NULL`. Defaults to `20`. #' @param batch_size an integer that gives the number of design points to be chosen. Defaults to `1`. #' @param M `r new_badge("new")` the size of the conditioning set for the Vecchia approximation in the criterion calculation. This argument is only used if the emulator `object` @@ -23,7 +27,7 @@ #' If a vector is provided, it will be converted to a two-column row matrix. The rows of the matrix correspond to input dimensions, and its #' first and second columns correspond to the minimum and maximum values of the input dimensions. This #' argument is only used when `x_cand = NULL`. Defaults to `NULL`. -#' @param int a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to +#' @param int `r new_badge("new")` a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to #' all input dimensions. If a vector is provided, it should have a length equal to the input dimensions and will be applied to individual #' input dimensions. This argument is only used when `x_cand = NULL`. Defaults to `FALSE`. #' @param aggregate an R function that aggregates scores of the ALM across different output dimensions (if `object` is an instance diff --git a/R/design.R b/R/design.R index 847a82b..62f4282 100644 --- a/R/design.R +++ b/R/design.R @@ -1,6 +1,10 @@ #' @title Sequential design of a (D)GP emulator or a bundle of (D)GP emulators #' -#' @description This function implements sequential design and active learning for a (D)GP emulator or +#' @description +#' +#' `r new_badge("updated")` +#' +#' This function implements sequential design and active learning for a (D)GP emulator or #' a bundle of (D)GP emulators, supporting an array of popular methods as well as user-specified approaches. #' It can also be used as a wrapper for Bayesian optimization methods. #' @@ -13,7 +17,7 @@ #' from which the next design points are determined. Defaults to `NULL`. #' @param y_cand a matrix (with each row being a simulator evaluation and column being an output dimension) that gives the realizations #' from the simulator at input positions in `x_cand`. Defaults to `NULL`. -#' @param n_sample an integer that gives the size of a sub-set to be sampled from the candidate set `x_cand` at each step of the sequential design to determine the next +#' @param n_sample `r new_badge("new")` an integer that gives the size of a sub-set to be sampled from the candidate set `x_cand` at each step of the sequential design to determine the next #' design point, if `x_cand` is not `NULL`. #' #' Defaults to `200`. @@ -59,7 +63,7 @@ #' Defaults to `FALSE`. #' @param target a number or vector specifying the target evaluation metric value(s) at which the sequential design should terminate. #' Defaults to `NULL`, in which case the sequential design stops after `N` steps. See the *Note* section below for further details about `target`. -#' @param method an R function that determines the next design points to be evaluated by `f`. The function must adhere to the following rules: +#' @param method `r new_badge("updated")` an R function that determines the next design points to be evaluated by `f`. The function must adhere to the following rules: #' - **First argument**: an emulator object, which can be one of the following: #' - an instance of the `gp` class (produced by [gp()]); #' - an instance of the `dgp` class (produced by [dgp()]); @@ -76,7 +80,7 @@ #' represent the new design points for the corresponding emulator. #' #' See [alm()], [mice()], and [vigf()] for examples of built-in `method` functions. Defaults to [vigf()]. -#' @param batch_size an integer specifying the number of design points to select in a single iteration. Defaults to `1`. +#' @param batch_size `r new_badge("new")` an integer specifying the number of design points to select in a single iteration. Defaults to `1`. #' This argument is used by the built-in `method` functions [alm()], [mice()], and [vigf()]. #' If you provide a custom `method` function with an argument named `batch_size`, the value of `batch_size` will be passed to your function. #' @param eval an R function that computes a customized metric for evaluating emulator performance. The function must adhere to the following rules: diff --git a/R/draw.R b/R/draw.R index 6b12d43..eba354f 100644 --- a/R/draw.R +++ b/R/draw.R @@ -1,6 +1,10 @@ #' @title Validation and diagnostic plots for a sequential design #' -#' @description This function draws diagnostic and validation plots for a sequential design of a (D)GP emulator or a bundle of (D)GP emulators. +#' @description +#' +#' `r new_badge("updated")` +#' +#' This function draws diagnostic and validation plots for a sequential design of a (D)GP emulator or a bundle of (D)GP emulators. #' #' @param object can be one of the following emulator classes: #' * the S3 class `gp`. @@ -13,7 +17,7 @@ #' Defaults to `"rmse"`. #' @param log a bool indicating whether to plot RMSEs, log-losses (for DGP emulators with categorical likelihoods), or custom evaluation metrics on a log scale when `type = "rmse"`. #' Defaults to `FALSE`. -#' @param emulator an index or vector of indices of emulators packed in `object`. This argument is only used if `object` is an instance of the `bundle` class. When set to `NULL`, all +#' @param emulator `r new_badge("updated")` an index or vector of indices of emulators packed in `object`. This argument is only used if `object` is an instance of the `bundle` class. When set to `NULL`, all #' emulators in the bundle are drawn. Defaults to `NULL`. #' @param ... N/A. #' diff --git a/R/lgp.R b/R/lgp.R index c4f91c2..133e328 100644 --- a/R/lgp.R +++ b/R/lgp.R @@ -1,6 +1,10 @@ #' @title Linked (D)GP emulator construction #' -#' @description This function constructs a linked (D)GP emulator for a model chain or network. +#' @description +#' +#' `r new_badge("updated")` +#' +#' This function constructs a linked (D)GP emulator for a model chain or network. #' #' @param struc the structure of the linked emulator, which can take one of two forms: #' - `r lifecycle::badge("deprecated")` a list contains *L* (the number of layers in a systems of computer models) sub-lists, diff --git a/R/mice.R b/R/mice.R index 45e4f3c..6754274 100644 --- a/R/mice.R +++ b/R/mice.R @@ -1,6 +1,10 @@ #' @title Locate the next design point for a (D)GP emulator or a bundle of (D)GP emulators using MICE #' -#' @description This function searches from a candidate set to locate the next design point(s) to be added to a (D)GP emulator +#' @description +#' +#' `r new_badge("updated")` +#' +#' This function searches from a candidate set to locate the next design point(s) to be added to a (D)GP emulator #' or a bundle of (D)GP emulators using the Mutual Information for Computer Experiments (MICE), see the reference below. #' #' @param object can be one of the following: @@ -20,11 +24,11 @@ #' @param nugget_s the value of the smoothing nugget term used by MICE. Defaults to `1e-6`. #' @param workers the number of processes to be used for the criterion calculation. If set to `NULL`, #' the number of processes is set to `max physical cores available %/% 2`. Defaults to `1`. -#' @param limits a two-column matrix that gives the ranges of each input dimension, or a vector of length two if there is only one input dimension. +#' @param limits `r new_badge("new")` a two-column matrix that gives the ranges of each input dimension, or a vector of length two if there is only one input dimension. #' If a vector is provided, it will be converted to a two-column row matrix. The rows of the matrix correspond to input dimensions, and its #' first and second columns correspond to the minimum and maximum values of the input dimensions. This #' argument is only used when `x_cand = NULL`. Defaults to `NULL`. -#' @param int a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to +#' @param int `r new_badge("new")` a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to #' all input dimensions. If a vector is provided, it should have a length equal to the input dimensions and will be applied to individual #' input dimensions. This argument is only used when `x_cand = NULL`. Defaults to `FALSE`. #' @param aggregate an R function that aggregates scores of the MICE across different output dimensions (if `object` is an instance diff --git a/R/plot.R b/R/plot.R index fcfa294..42b9f45 100644 --- a/R/plot.R +++ b/R/plot.R @@ -1,6 +1,10 @@ #' @title Validation plots of a constructed GP, DGP, or linked (D)GP emulator #' -#' @description This function draws validation plots of a GP, DGP, or linked (D)GP emulator. +#' @description +#' +#' `r new_badge("updated")` +#' +#' This function draws validation plots of a GP, DGP, or linked (D)GP emulator. #' #' @param x can be one of the following emulator classes: #' * the S3 class `gp`. @@ -8,7 +12,7 @@ #' * the S3 class `lgp`. #' @param x_test same as that of [validate()]. #' @param y_test same as that of [validate()]. -#' @param dim if `dim = NULL`, the index of an emulator's input within the design will be shown on the x-axis in validation plots. Otherwise, `dim` indicates +#' @param dim `r new_badge("updated")` if `dim = NULL`, the index of an emulator's input within the design will be shown on the x-axis in validation plots. Otherwise, `dim` indicates #' which dimension of an emulator's input will be shown on the x-axis in validation plots: #' * If `x` is an instance of the `gp` of `dgp` class, `dim` is an integer. #' * `r lifecycle::badge("deprecated")` If `x` is an instance of the `lgp` class created by [lgp()] without specifying the `struc` argument in data frame form, `dim` can be: diff --git a/R/prediction.R b/R/prediction.R index 0118d0f..c50755f 100644 --- a/R/prediction.R +++ b/R/prediction.R @@ -1,7 +1,10 @@ #' @title Prediction from GP, DGP, or linked (D)GP emulators #' -#' @description This function implements single-core or multi-core prediction (with or without multi-threading) -#' from GP, DGP, or linked (D)GP emulators. +#' @description +#' +#' `r new_badge("updated")` +#' +#' This function implements prediction from GP, DGP, or linked (D)GP emulators. #' #' @param object an instance of the `gp`, `dgp`, or `lgp` class. #' @param x the testing input data: diff --git a/R/serialization.R b/R/serialization.R index bd5bf02..d3d0fcc 100644 --- a/R/serialization.R +++ b/R/serialization.R @@ -1,6 +1,10 @@ #' @title Serialize the constructed emulator #' -#' @description This function serialize the constructed emulator. +#' @description +#' +#' `r new_badge("new")` +#' +#' This function serialize the constructed emulator. #' #' @param object an instance of the S3 class `gp`, `dgp`, `lgp`, or `bundle`. #' @param light a bool indicating if a light version of the constructed emulator (that requires a small storage) will be serialized. @@ -98,7 +102,11 @@ serialize <- function(object, light = TRUE) { #' @title Restore the serialized emulator #' -#' @description This function restores the serialized emulator created by [serialize()]. +#' @description +#' +#' `r new_badge("new")` +#' +#' This function restores the serialized emulator created by [serialize()]. #' #' @param object the serialized object of an emulator. #' diff --git a/R/vigf.R b/R/vigf.R index 156edea..52a73bb 100644 --- a/R/vigf.R +++ b/R/vigf.R @@ -1,6 +1,10 @@ #' @title Locate the next design point for a (D)GP emulator or a bundle of (D)GP emulators using VIGF #' -#' @description This function searches from a candidate set to locate the next design point(s) to be added to a (D)GP emulator +#' @description +#' +#' `r new_badge("updated")` +#' +#' This function searches from a candidate set to locate the next design point(s) to be added to a (D)GP emulator #' or a bundle of (D)GP emulators using the Variance of Improvement for Global Fit (VIGF). For VIGF on GP emulators, see the reference below. #' #' @param object can be one of the following: @@ -11,7 +15,7 @@ #' from which the next design point(s) are determined. If `object` is an instance of the `bundle` class and `aggregate` is not supplied, `x_cand` can also be a list. #' The list must have a length equal to the number of emulators in `object`, with each element being a matrix representing the candidate set for a corresponding #' emulator in the bundle. Defaults to `NULL`. -#' @param n_start an integer that gives the number of initial design points to be used to determine next design point(s). This argument +#' @param n_start `r new_badge("new")` an integer that gives the number of initial design points to be used to determine next design point(s). This argument #' is only used when `x_cand` is `NULL`. Defaults to `10`. #' @param batch_size an integer that gives the number of design points to be chosen. #' Defaults to `1`. @@ -20,11 +24,11 @@ #' @param workers the number of processes to be used for design point selection. If set to `NULL`, #' the number of processes is set to `max physical cores available %/% 2`. Defaults to `1`. The argument does not currently support Windows machines when the `aggregate` #' function is provided, due to the significant overhead caused by initializing the Python environment for each worker under spawning. -#' @param limits a two-column matrix that gives the ranges of each input dimension, or a vector of length two if there is only one input dimension. +#' @param limits `r new_badge("new")` a two-column matrix that gives the ranges of each input dimension, or a vector of length two if there is only one input dimension. #' If a vector is provided, it will be converted to a two-column row matrix. The rows of the matrix correspond to input dimensions, and its #' first and second columns correspond to the minimum and maximum values of the input dimensions. This #' argument is only used when `x_cand = NULL`. Defaults to `NULL`. -#' @param int a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to +#' @param int `r new_badge("new")` a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to #' all input dimensions. If a vector is provided, it should have a length equal to the input dimensions and will be applied to individual #' input dimensions. This argument is only used when `x_cand = NULL`. Defaults to `FALSE`. #' @param aggregate an R function that aggregates scores of the VIGF across different output dimensions (if `object` is an instance diff --git a/man/alm.Rd b/man/alm.Rd index 20cb135..7cc16b7 100644 --- a/man/alm.Rd +++ b/man/alm.Rd @@ -63,7 +63,7 @@ from which the next design point(s) are determined. If \code{object} is an insta The list must have a length equal to the number of emulators in \code{object}, with each element being a matrix representing the candidate set for a corresponding emulator in the bundle. Defaults to \code{NULL}.} -\item{n_start}{an integer that gives the number of initial design points to be used to determine next design point(s). This argument +\item{n_start}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} an integer that gives the number of initial design points to be used to determine next design point(s). This argument is only used when \code{x_cand} is \code{NULL}. Defaults to \code{20}.} \item{batch_size}{an integer that gives the number of design points to be chosen. Defaults to \code{1}.} @@ -80,7 +80,7 @@ If a vector is provided, it will be converted to a two-column row matrix. The ro first and second columns correspond to the minimum and maximum values of the input dimensions. This argument is only used when \code{x_cand = NULL}. Defaults to \code{NULL}.} -\item{int}{a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to +\item{int}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to all input dimensions. If a vector is provided, it should have a length equal to the input dimensions and will be applied to individual input dimensions. This argument is only used when \code{x_cand = NULL}. Defaults to \code{FALSE}.} @@ -130,6 +130,8 @@ element of the list is a matrix with \code{batch_size} rows, where each row repr } } \description{ +\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} + This function searches from a candidate set to locate the next design point(s) to be added to a (D)GP emulator or a bundle of (D)GP emulators using the Active Learning MacKay (ALM) criterion (see the reference below). } diff --git a/man/deserialize.Rd b/man/deserialize.Rd index 4a08332..3200ef6 100644 --- a/man/deserialize.Rd +++ b/man/deserialize.Rd @@ -13,6 +13,8 @@ deserialize(object) The S3 class of a GP emulator, a DGP emulator, a linked (D)GP emulator, or a bundle of (D)GP emulators. } \description{ +\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} + This function restores the serialized emulator created by \code{\link[=serialize]{serialize()}}. } \details{ diff --git a/man/design.Rd b/man/design.Rd index e3238de..4cbd3a0 100644 --- a/man/design.Rd +++ b/man/design.Rd @@ -133,7 +133,7 @@ from which the next design points are determined. Defaults to \code{NULL}.} \item{y_cand}{a matrix (with each row being a simulator evaluation and column being an output dimension) that gives the realizations from the simulator at input positions in \code{x_cand}. Defaults to \code{NULL}.} -\item{n_sample}{an integer that gives the size of a sub-set to be sampled from the candidate set \code{x_cand} at each step of the sequential design to determine the next +\item{n_sample}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} an integer that gives the size of a sub-set to be sampled from the candidate set \code{x_cand} at each step of the sequential design to determine the next design point, if \code{x_cand} is not \code{NULL}. Defaults to \code{200}.} @@ -199,7 +199,7 @@ Defaults to \code{FALSE}.} \item{target}{a number or vector specifying the target evaluation metric value(s) at which the sequential design should terminate. Defaults to \code{NULL}, in which case the sequential design stops after \code{N} steps. See the \emph{Note} section below for further details about \code{target}.} -\item{method}{an R function that determines the next design points to be evaluated by \code{f}. The function must adhere to the following rules: +\item{method}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} an R function that determines the next design points to be evaluated by \code{f}. The function must adhere to the following rules: \itemize{ \item \strong{First argument}: an emulator object, which can be one of the following: \itemize{ @@ -227,7 +227,7 @@ represent the new design points for the corresponding emulator. See \code{\link[=alm]{alm()}}, \code{\link[=mice]{mice()}}, and \code{\link[=vigf]{vigf()}} for examples of built-in \code{method} functions. Defaults to \code{\link[=vigf]{vigf()}}.} -\item{batch_size}{an integer specifying the number of design points to select in a single iteration. Defaults to \code{1}. +\item{batch_size}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} an integer specifying the number of design points to select in a single iteration. Defaults to \code{1}. This argument is used by the built-in \code{method} functions \code{\link[=alm]{alm()}}, \code{\link[=mice]{mice()}}, and \code{\link[=vigf]{vigf()}}. If you provide a custom \code{method} function with an argument named \code{batch_size}, the value of \code{batch_size} will be passed to your function.} @@ -361,6 +361,8 @@ avoid re-visiting the same locations in later runs of \code{design()}. See \emph{Note} section below for further information. } \description{ +\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} + This function implements sequential design and active learning for a (D)GP emulator or a bundle of (D)GP emulators, supporting an array of popular methods as well as user-specified approaches. It can also be used as a wrapper for Bayesian optimization methods. diff --git a/man/draw.Rd b/man/draw.Rd index a01f67e..f48b209 100644 --- a/man/draw.Rd +++ b/man/draw.Rd @@ -36,13 +36,15 @@ Defaults to \code{"rmse"}.} \item{log}{a bool indicating whether to plot RMSEs, log-losses (for DGP emulators with categorical likelihoods), or custom evaluation metrics on a log scale when \code{type = "rmse"}. Defaults to \code{FALSE}.} -\item{emulator}{an index or vector of indices of emulators packed in \code{object}. This argument is only used if \code{object} is an instance of the \code{bundle} class. When set to \code{NULL}, all +\item{emulator}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} an index or vector of indices of emulators packed in \code{object}. This argument is only used if \code{object} is an instance of the \code{bundle} class. When set to \code{NULL}, all emulators in the bundle are drawn. Defaults to \code{NULL}.} } \value{ A \code{patchwork} object. } \description{ +\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} + This function draws diagnostic and validation plots for a sequential design of a (D)GP emulator or a bundle of (D)GP emulators. } \details{ diff --git a/man/lgp.Rd b/man/lgp.Rd index fc4d2e4..1cbb0f2 100644 --- a/man/lgp.Rd +++ b/man/lgp.Rd @@ -100,6 +100,8 @@ The returned \code{lgp} object can be used by } } \description{ +\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} + This function constructs a linked (D)GP emulator for a model chain or network. } \details{ diff --git a/man/mice.Rd b/man/mice.Rd index a60669e..4dd84eb 100644 --- a/man/mice.Rd +++ b/man/mice.Rd @@ -80,12 +80,12 @@ was constructed under the Vecchia approximation. Defaults to \code{50}.} \item{workers}{the number of processes to be used for the criterion calculation. If set to \code{NULL}, the number of processes is set to \verb{max physical cores available \%/\% 2}. Defaults to \code{1}.} -\item{limits}{a two-column matrix that gives the ranges of each input dimension, or a vector of length two if there is only one input dimension. +\item{limits}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} a two-column matrix that gives the ranges of each input dimension, or a vector of length two if there is only one input dimension. If a vector is provided, it will be converted to a two-column row matrix. The rows of the matrix correspond to input dimensions, and its first and second columns correspond to the minimum and maximum values of the input dimensions. This argument is only used when \code{x_cand = NULL}. Defaults to \code{NULL}.} -\item{int}{a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to +\item{int}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to all input dimensions. If a vector is provided, it should have a length equal to the input dimensions and will be applied to individual input dimensions. This argument is only used when \code{x_cand = NULL}. Defaults to \code{FALSE}.} @@ -135,6 +135,8 @@ element of the list is a matrix with \code{batch_size} rows, where each row repr } } \description{ +\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} + This function searches from a candidate set to locate the next design point(s) to be added to a (D)GP emulator or a bundle of (D)GP emulators using the Mutual Information for Computer Experiments (MICE), see the reference below. } diff --git a/man/plot.Rd b/man/plot.Rd index 6da2eda..428640c 100644 --- a/man/plot.Rd +++ b/man/plot.Rd @@ -74,7 +74,7 @@ \item{y_test}{same as that of \code{\link[=validate]{validate()}}.} -\item{dim}{if \code{dim = NULL}, the index of an emulator's input within the design will be shown on the x-axis in validation plots. Otherwise, \code{dim} indicates +\item{dim}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} if \code{dim = NULL}, the index of an emulator's input within the design will be shown on the x-axis in validation plots. Otherwise, \code{dim} indicates which dimension of an emulator's input will be shown on the x-axis in validation plots: \itemize{ \item If \code{x} is an instance of the \code{gp} of \code{dgp} class, \code{dim} is an integer. @@ -138,6 +138,8 @@ Defaults to \code{TRUE}.} A \code{patchwork} object. } \description{ +\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} + This function draws validation plots of a GP, DGP, or linked (D)GP emulator. } \details{ diff --git a/man/predict.Rd b/man/predict.Rd index debcc12..98e6801 100644 --- a/man/predict.Rd +++ b/man/predict.Rd @@ -193,8 +193,9 @@ The \code{results} slot will also include: } } \description{ -This function implements single-core or multi-core prediction (with or without multi-threading) -from GP, DGP, or linked (D)GP emulators. +\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} + +This function implements prediction from GP, DGP, or linked (D)GP emulators. } \details{ See further examples and tutorials at \url{https://mingdeyu.github.io/dgpsi-R/dev/}. diff --git a/man/serialize.Rd b/man/serialize.Rd index b27b995..701bb16 100644 --- a/man/serialize.Rd +++ b/man/serialize.Rd @@ -16,6 +16,8 @@ Defaults to \code{TRUE}.} A serialized version of \code{object}. } \description{ +\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} + This function serialize the constructed emulator. } \details{ diff --git a/man/vigf.Rd b/man/vigf.Rd index 991274f..b80137f 100644 --- a/man/vigf.Rd +++ b/man/vigf.Rd @@ -63,7 +63,7 @@ from which the next design point(s) are determined. If \code{object} is an insta The list must have a length equal to the number of emulators in \code{object}, with each element being a matrix representing the candidate set for a corresponding emulator in the bundle. Defaults to \code{NULL}.} -\item{n_start}{an integer that gives the number of initial design points to be used to determine next design point(s). This argument +\item{n_start}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} an integer that gives the number of initial design points to be used to determine next design point(s). This argument is only used when \code{x_cand} is \code{NULL}. Defaults to \code{10}.} \item{batch_size}{an integer that gives the number of design points to be chosen. @@ -76,12 +76,12 @@ was constructed under the Vecchia approximation. Defaults to \code{50}.} the number of processes is set to \verb{max physical cores available \%/\% 2}. Defaults to \code{1}. The argument does not currently support Windows machines when the \code{aggregate} function is provided, due to the significant overhead caused by initializing the Python environment for each worker under spawning.} -\item{limits}{a two-column matrix that gives the ranges of each input dimension, or a vector of length two if there is only one input dimension. +\item{limits}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} a two-column matrix that gives the ranges of each input dimension, or a vector of length two if there is only one input dimension. If a vector is provided, it will be converted to a two-column row matrix. The rows of the matrix correspond to input dimensions, and its first and second columns correspond to the minimum and maximum values of the input dimensions. This argument is only used when \code{x_cand = NULL}. Defaults to \code{NULL}.} -\item{int}{a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to +\item{int}{\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#new}{\figure{lifecycle-new.svg}{options: alt='[New]'}}}{\strong{[New]}} a bool or a vector of bools that indicates if an input dimension is an integer type. If a single bool is given, it will be applied to all input dimensions. If a vector is provided, it should have a length equal to the input dimensions and will be applied to individual input dimensions. This argument is only used when \code{x_cand = NULL}. Defaults to \code{FALSE}.} @@ -131,6 +131,8 @@ element of the list is a matrix with \code{batch_size} rows, where each row repr } } \description{ +\ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#updated}{\figure{lifecycle-updated.svg}{options: alt='[Updated]'}}}{\strong{[Updated]}} + This function searches from a candidate set to locate the next design point(s) to be added to a (D)GP emulator or a bundle of (D)GP emulators using the Variance of Improvement for Global Fit (VIGF). For VIGF on GP emulators, see the reference below. }