Optimizer: Specify numerical optimizer object
In optimizeR: Unified Framework for Numerical Optimizers
Optimizer R Documentation
Specify numerical optimizer object
Description
The Optimizer object defines a numerical optimizer based on any
optimization algorithm implemented in R. The main advantage of working with
an Optimizer object instead of using the optimization function
directly lies in the standardized inputs and outputs.
Any R function that fulfills the following four constraints can be defined as
an Optimizer object:
It must have an input for a function, the objective function to be
optimized.
It must have an input for a numeric vector, the initial values from
where the optimizer starts.
It must have a ... argument for additional parameters passed on to
the objective function.
The output must be a named list, including the optimal function
value and the optimal parameter vector.
Active bindings
label[character(1)]
The label for the optimizer.
algorithm[function]
The optimization algorithm.
arg_objective[character(1)]
The argument name for the objective function in algorithm.
arg_initial[character(1)]
The argument name for the initial values in algorithm.
arg_lower[character(1) | NA]
Optionally the argument name for the lower parameter bound in
algorithm.
Can be NA if not available.
arg_upper[character(1) | NA]
Optionally the argument name for the upper parameter bound in
algorithm.
Can be NA if not available.
arg_gradient[character(1) | NA]
Optionally the argument name for the gradient function in
algorithm.
Can be NA if not available.
arg_hessian[character(1) | NA]
Optionally the argument name for the Hessian function in
algorithm.
Can be NA if not available.
gradient_as_attribute[logical(1)]
Only relevant if arg_gradient is not NA.
In that case, does algorithm expect that the gradient is an attribute
of the objective function output (as for example in
nlm)? In that case, arg_gradient defines the
attribute name.
hessian_as_attribute[logical(1)]
Only relevant if arg_hessian is not NA.
In that case, does algorithm expect that the Hessian is an attribute
of the objective function output (as for example in
nlm)? In that case, arg_hessian defines the
attribute name.
out_value[character(1)]
The element name for the optimal function value in the output list
of algorithm.
out_parameter[character(1)]
The element name for the optimal parameters in the output list of
algorithm.
direction[character(1)]
Either "min" (if the optimizer minimizes) or "max"
(if the optimizer maximizes).
arguments[list()]
Custom arguments for algorithm.
Defaults are used for arguments that are not specified.
seconds[numeric(1)]
A time limit in seconds.
Optimization is interrupted prematurely if seconds is exceeded.
No time limit if seconds = Inf (the default).
Note the limitations documented in setTimeLimit.
hide_warnings[logical(1)]
Hide warnings during optimization?
output_ignore[character()]
Elements to ignore (not include) in the optimization output.
Methods
Public methods
-
-
-
-
-
-
-
-
Method new()
Initializes a new Optimizer object.
Usage
Optimizer$new(which, ..., .verbose = TRUE)
Arguments
which[character(1)]
Either:
one of optimizer_dictionary$keys
or "custom", in which case $definition() must be used to
define the optimizer details.
...[any]
Optionally additional named arguments to be passed to the optimizer
algorithm. Without specifications, default values of the optimizer are used.
.verbose[logical(1)]
Print status messages?
Returns
A new Optimizer object.
Method definition()
Defines an optimizer.
Usage
Optimizer$definition(
algorithm,
arg_objective,
arg_initial,
arg_lower = NA,
arg_upper = NA,
arg_gradient = NA,
arg_hessian = NA,
gradient_as_attribute = FALSE,
hessian_as_attribute = FALSE,
out_value,
out_parameter,
direction
)
Arguments
algorithm[function]
The optimization algorithm.
arg_objective[character(1)]
The argument name for the objective function in algorithm.
arg_initial[character(1)]
The argument name for the initial values in algorithm.
arg_lower[character(1) | NA]
Optionally the argument name for the lower parameter bound in
algorithm.
Can be NA if not available.
arg_upper[character(1) | NA]
Optionally the argument name for the upper parameter bound in
algorithm.
Can be NA if not available.
arg_gradient[character(1) | NA]
Optionally the argument name for the gradient function in
algorithm.
Can be NA if not available.
arg_hessian[character(1) | NA]
Optionally the argument name for the Hessian function in
algorithm.
Can be NA if not available.
gradient_as_attribute[logical(1)]
Only relevant if arg_gradient is not NA.
In that case, does algorithm expect that the gradient is an attribute
of the objective function output (as for example in
nlm)? In that case, arg_gradient defines the
attribute name.
hessian_as_attribute[logical(1)]
Only relevant if arg_hessian is not NA.
In that case, does algorithm expect that the Hessian is an attribute
of the objective function output (as for example in
nlm)? In that case, arg_hessian defines the
attribute name.
out_value[character(1)]
The element name for the optimal function value in the output list
of algorithm.
out_parameter[character(1)]
The element name for the optimal parameters in the output list of
algorithm.
direction[character(1)]
Either "min" (if the optimizer minimizes) or "max"
(if the optimizer maximizes).
Method set_arguments()
Sets optimizer arguments.
Usage
Optimizer$set_arguments(...)
Arguments
...[any]
Optionally additional named arguments to be passed to the optimizer
algorithm. Without specifications, default values of the optimizer are used.
Returns
The Optimizer object.
Method minimize()
Performing minimization.
Usage
Optimizer$minimize(objective, initial, lower = NA, upper = NA, ...)
Arguments
objective[function | Objective]
A function to be optimized that
has at least one argument that receives a numeric vector
and returns a single numeric value.
Alternatively, it can also be an Objective object for more
flexibility.
initial[numeric()]
Starting parameter values for the optimization.
lower[NA | numeric() | numeric(1)]
Lower bounds on the parameters.
If a single number, this will be applied to all parameters.
Can be NA to not define any bounds.
upper[NA | numeric() | numeric(1)]
Upper bounds on the parameters.
If a single number, this will be applied to all parameters.
Can be NA to not define any bounds.
...[any]
Optionally additional named arguments to be passed to the optimizer
algorithm. Without specifications, default values of the optimizer are used.
Returns
A named list, containing at least these five elements:
valueA numeric, the minimum function value.
parameterA numeric vector, the parameter vector
where the minimum is obtained.
secondsA numeric, the optimization time in seconds.
initialA numeric, the initial parameter values.
errorEither TRUE if an error occurred, or FALSE, else.
Appended are additional output elements of the optimizer.
If an error occurred, then the error message is also appended as element
error_message.
If the time limit was exceeded, this counts as an error. In addition,
the flag time_out = TRUE is appended.
Examples
Optimizer$new("stats::nlm")$
minimize(objective = function(x) x^4 + 3*x - 5, initial = 2)
Method maximize()
Performing maximization.
Usage
Optimizer$maximize(objective, initial, lower = NA, upper = NA, ...)
Arguments
objective[function | Objective]
A function to be optimized that
has at least one argument that receives a numeric vector
and returns a single numeric value.
Alternatively, it can also be an Objective object for more
flexibility.
initial[numeric()]
Starting parameter values for the optimization.
lower[NA | numeric() | numeric(1)]
Lower bounds on the parameters.
If a single number, this will be applied to all parameters.
Can be NA to not define any bounds.
upper[NA | numeric() | numeric(1)]
Upper bounds on the parameters.
If a single number, this will be applied to all parameters.
Can be NA to not define any bounds.
...[any]
Optionally additional named arguments to be passed to the optimizer
algorithm. Without specifications, default values of the optimizer are used.
Returns
A named list, containing at least these five elements:
valueA numeric, the maximum function value.
parameterA numeric vector, the parameter vector
where the maximum is obtained.
secondsA numeric, the optimization time in seconds.
initialA numeric, the initial parameter values.
errorEither TRUE if an error occurred, or FALSE, else.
Appended are additional output elements of the optimizer.
If an error occurred, then the error message is also appended as element
error_message.
If the time limit was exceeded, this also counts as an error. In addition,
the flag time_out = TRUE is appended.
Examples
Optimizer$new("stats::nlm")$
maximize(objective = function(x) -x^4 + 3*x - 5, initial = 2)
Method optimize()
Performing minimization or maximization.
Usage
Optimizer$optimize(
objective,
initial,
lower = NA,
upper = NA,
direction = "min",
...
)
Arguments
objective[function | Objective]
A function to be optimized that
has at least one argument that receives a numeric vector
and returns a single numeric value.
Alternatively, it can also be an Objective object for more
flexibility.
initial[numeric()]
Starting parameter values for the optimization.
lower[NA | numeric() | numeric(1)]
Lower bounds on the parameters.
If a single number, this will be applied to all parameters.
Can be NA to not define any bounds.
upper[NA | numeric() | numeric(1)]
Upper bounds on the parameters.
If a single number, this will be applied to all parameters.
Can be NA to not define any bounds.
direction[character(1)]
Either "min" for minimization or "max" for maximization.
...[any]
Optionally additional named arguments to be passed to the optimizer
algorithm. Without specifications, default values of the optimizer are used.
Returns
A named list, containing at least these five elements:
valueA numeric, the maximum function value.
parameterA numeric vector, the parameter vector
where the maximum is obtained.
secondsA numeric, the optimization time in seconds.
initialA numeric, the initial parameter values.
errorEither TRUE if an error occurred, or FALSE, else.
Appended are additional output elements of the optimizer.
If an error occurred, then the error message is also appended as element
error_message.
If the time limit was exceeded, this also counts as an error. In addition,
the flag time_out = TRUE is appended.
Examples
objective <- function(x) -x^4 + 3*x - 5
optimizer <- Optimizer$new("stats::nlm")
optimizer$optimize(objective = objective, initial = 2, direction = "min")
optimizer$optimize(objective = objective, initial = 2, direction = "max")
Method print()
Prints the optimizer label.
Usage
Optimizer$print(...)
Arguments
...[any]
Optionally additional named arguments to be passed to the optimizer
algorithm. Without specifications, default values of the optimizer are used.
Returns
Invisibly the Optimizer object.
Method clone()
The objects of this class are cloneable with this method.
Usage
Optimizer$clone(deep = FALSE)
Arguments
deepWhether to make a deep clone.
Examples
### Task: compare minimization with 'stats::nlm' and 'pracma::nelder_mead'
# 1. define objective function and initial values
objective <- TestFunctions::TF_ackley
initial <- c(3, 3)
# 2. get overview of optimizers available in dictionary
optimizer_dictionary$keys
# 3. define 'nlm' optimizer
nlm <- Optimizer$new(which = "stats::nlm")
# 4. define the 'pracma::nelder_mead' optimizer (not contained in the dictionary)
nelder_mead <- Optimizer$new(which = "custom")
nelder_mead$definition(
algorithm = pracma::nelder_mead, # the optimization function
arg_objective = "fn", # the argument name for the objective function
arg_initial = "x0", # the argument name for the initial values
out_value = "fmin", # the element for the optimal function value in the output
out_parameter = "xmin", # the element for the optimal parameters in the output
direction = "min" # the optimizer minimizes
)
# 5. compare the minimization results
nlm$minimize(objective, initial)
nelder_mead$minimize(objective, initial)
## ------------------------------------------------
## Method `Optimizer$minimize`
## ------------------------------------------------
Optimizer$new("stats::nlm")$
minimize(objective = function(x) x^4 + 3*x - 5, initial = 2)
## ------------------------------------------------
## Method `Optimizer$maximize`
## ------------------------------------------------
Optimizer$new("stats::nlm")$
maximize(objective = function(x) -x^4 + 3*x - 5, initial = 2)
## ------------------------------------------------
## Method `Optimizer$optimize`
## ------------------------------------------------
objective <- function(x) -x^4 + 3*x - 5
optimizer <- Optimizer$new("stats::nlm")
optimizer$optimize(objective = objective, initial = 2, direction = "min")
optimizer$optimize(objective = objective, initial = 2, direction = "max")
optimizeR documentation built on June 8, 2025, 10:35 a.m.
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
| Optimizer | R Documentation |
Specify numerical optimizer object
Description
The Optimizer object defines a numerical optimizer based on any
optimization algorithm implemented in R. The main advantage of working with
an Optimizer object instead of using the optimization function
directly lies in the standardized inputs and outputs.
Any R function that fulfills the following four constraints can be defined as
an Optimizer object:
It must have an input for a
function, the objective function to be optimized.It must have an input for a
numericvector, the initial values from where the optimizer starts.It must have a
...argument for additional parameters passed on to the objective function.The output must be a named
list, including the optimal function value and the optimal parameter vector.
Active bindings
label[
character(1)]
The label for the optimizer.algorithm[
function]
The optimization algorithm.arg_objective[
character(1)]
The argument name for the objective function inalgorithm.arg_initial[
character(1)]
The argument name for the initial values inalgorithm.arg_lower[
character(1)|NA]
Optionally the argument name for the lower parameter bound inalgorithm.Can be
NAif not available.arg_upper[
character(1)|NA]
Optionally the argument name for the upper parameter bound inalgorithm.Can be
NAif not available.arg_gradient[
character(1)|NA]
Optionally the argument name for the gradient function inalgorithm.Can be
NAif not available.arg_hessian[
character(1)|NA]
Optionally the argument name for the Hessian function inalgorithm.Can be
NAif not available.gradient_as_attribute[
logical(1)]
Only relevant ifarg_gradientis notNA.In that case, does
algorithmexpect that the gradient is an attribute of the objective function output (as for example innlm)? In that case,arg_gradientdefines the attribute name.hessian_as_attribute[
logical(1)]
Only relevant ifarg_hessianis notNA.In that case, does
algorithmexpect that the Hessian is an attribute of the objective function output (as for example innlm)? In that case,arg_hessiandefines the attribute name.out_value[
character(1)]
The element name for the optimal function value in the outputlistofalgorithm.out_parameter[
character(1)]
The element name for the optimal parameters in the outputlistofalgorithm.direction[
character(1)]
Either"min"(if the optimizer minimizes) or"max"(if the optimizer maximizes).arguments[
list()]
Custom arguments foralgorithm.Defaults are used for arguments that are not specified.
seconds[
numeric(1)]
A time limit in seconds.Optimization is interrupted prematurely if
secondsis exceeded.No time limit if
seconds = Inf(the default).Note the limitations documented in
setTimeLimit.hide_warnings[
logical(1)]
Hide warnings during optimization?output_ignore[
character()]
Elements to ignore (not include) in the optimization output.
Methods
Public methods
Method new()
Initializes a new Optimizer object.
Usage
Optimizer$new(which, ..., .verbose = TRUE)
Arguments
which[
character(1)]
Either:one of
optimizer_dictionary$keysor
"custom", in which case$definition()must be used to define the optimizer details.
...[
any]
Optionally additional named arguments to be passed to the optimizer algorithm. Without specifications, default values of the optimizer are used..verbose[
logical(1)]
Print status messages?
Returns
A new Optimizer object.
Method definition()
Defines an optimizer.
Usage
Optimizer$definition( algorithm, arg_objective, arg_initial, arg_lower = NA, arg_upper = NA, arg_gradient = NA, arg_hessian = NA, gradient_as_attribute = FALSE, hessian_as_attribute = FALSE, out_value, out_parameter, direction )
Arguments
algorithm[
function]
The optimization algorithm.arg_objective[
character(1)]
The argument name for the objective function inalgorithm.arg_initial[
character(1)]
The argument name for the initial values inalgorithm.arg_lower[
character(1)|NA]
Optionally the argument name for the lower parameter bound inalgorithm.Can be
NAif not available.arg_upper[
character(1)|NA]
Optionally the argument name for the upper parameter bound inalgorithm.Can be
NAif not available.arg_gradient[
character(1)|NA]
Optionally the argument name for the gradient function inalgorithm.Can be
NAif not available.arg_hessian[
character(1)|NA]
Optionally the argument name for the Hessian function inalgorithm.Can be
NAif not available.gradient_as_attribute[
logical(1)]
Only relevant ifarg_gradientis notNA.In that case, does
algorithmexpect that the gradient is an attribute of the objective function output (as for example innlm)? In that case,arg_gradientdefines the attribute name.hessian_as_attribute[
logical(1)]
Only relevant ifarg_hessianis notNA.In that case, does
algorithmexpect that the Hessian is an attribute of the objective function output (as for example innlm)? In that case,arg_hessiandefines the attribute name.out_value[
character(1)]
The element name for the optimal function value in the outputlistofalgorithm.out_parameter[
character(1)]
The element name for the optimal parameters in the outputlistofalgorithm.direction[
character(1)]
Either"min"(if the optimizer minimizes) or"max"(if the optimizer maximizes).
Method set_arguments()
Sets optimizer arguments.
Usage
Optimizer$set_arguments(...)
Arguments
...[
any]
Optionally additional named arguments to be passed to the optimizer algorithm. Without specifications, default values of the optimizer are used.
Returns
The Optimizer object.
Method minimize()
Performing minimization.
Usage
Optimizer$minimize(objective, initial, lower = NA, upper = NA, ...)
Arguments
objective[
function|Objective]
Afunctionto be optimized thathas at least one argument that receives a
numericvectorand returns a single
numericvalue.
Alternatively, it can also be an
Objectiveobject for more flexibility.initial[
numeric()]
Starting parameter values for the optimization.lower[
NA|numeric()|numeric(1)]
Lower bounds on the parameters.If a single number, this will be applied to all parameters.
Can be
NAto not define any bounds.upper[
NA|numeric()|numeric(1)]
Upper bounds on the parameters.If a single number, this will be applied to all parameters.
Can be
NAto not define any bounds....[
any]
Optionally additional named arguments to be passed to the optimizer algorithm. Without specifications, default values of the optimizer are used.
Returns
A named list, containing at least these five elements:
valueA
numeric, the minimum function value.parameterA
numericvector, the parameter vector where the minimum is obtained.secondsA
numeric, the optimization time in seconds.initialA
numeric, the initial parameter values.errorEither
TRUEif an error occurred, orFALSE, else.
Appended are additional output elements of the optimizer.
If an error occurred, then the error message is also appended as element
error_message.
If the time limit was exceeded, this counts as an error. In addition,
the flag time_out = TRUE is appended.
Examples
Optimizer$new("stats::nlm")$
minimize(objective = function(x) x^4 + 3*x - 5, initial = 2)
Method maximize()
Performing maximization.
Usage
Optimizer$maximize(objective, initial, lower = NA, upper = NA, ...)
Arguments
objective[
function|Objective]
Afunctionto be optimized thathas at least one argument that receives a
numericvectorand returns a single
numericvalue.
Alternatively, it can also be an
Objectiveobject for more flexibility.initial[
numeric()]
Starting parameter values for the optimization.lower[
NA|numeric()|numeric(1)]
Lower bounds on the parameters.If a single number, this will be applied to all parameters.
Can be
NAto not define any bounds.upper[
NA|numeric()|numeric(1)]
Upper bounds on the parameters.If a single number, this will be applied to all parameters.
Can be
NAto not define any bounds....[
any]
Optionally additional named arguments to be passed to the optimizer algorithm. Without specifications, default values of the optimizer are used.
Returns
A named list, containing at least these five elements:
valueA
numeric, the maximum function value.parameterA
numericvector, the parameter vector where the maximum is obtained.secondsA
numeric, the optimization time in seconds.initialA
numeric, the initial parameter values.errorEither
TRUEif an error occurred, orFALSE, else.
Appended are additional output elements of the optimizer.
If an error occurred, then the error message is also appended as element
error_message.
If the time limit was exceeded, this also counts as an error. In addition,
the flag time_out = TRUE is appended.
Examples
Optimizer$new("stats::nlm")$
maximize(objective = function(x) -x^4 + 3*x - 5, initial = 2)
Method optimize()
Performing minimization or maximization.
Usage
Optimizer$optimize( objective, initial, lower = NA, upper = NA, direction = "min", ... )
Arguments
objective[
function|Objective]
Afunctionto be optimized thathas at least one argument that receives a
numericvectorand returns a single
numericvalue.
Alternatively, it can also be an
Objectiveobject for more flexibility.initial[
numeric()]
Starting parameter values for the optimization.lower[
NA|numeric()|numeric(1)]
Lower bounds on the parameters.If a single number, this will be applied to all parameters.
Can be
NAto not define any bounds.upper[
NA|numeric()|numeric(1)]
Upper bounds on the parameters.If a single number, this will be applied to all parameters.
Can be
NAto not define any bounds.direction[
character(1)]
Either"min"for minimization or"max"for maximization....[
any]
Optionally additional named arguments to be passed to the optimizer algorithm. Without specifications, default values of the optimizer are used.
Returns
A named list, containing at least these five elements:
valueA
numeric, the maximum function value.parameterA
numericvector, the parameter vector where the maximum is obtained.secondsA
numeric, the optimization time in seconds.initialA
numeric, the initial parameter values.errorEither
TRUEif an error occurred, orFALSE, else.
Appended are additional output elements of the optimizer.
If an error occurred, then the error message is also appended as element
error_message.
If the time limit was exceeded, this also counts as an error. In addition,
the flag time_out = TRUE is appended.
Examples
objective <- function(x) -x^4 + 3*x - 5
optimizer <- Optimizer$new("stats::nlm")
optimizer$optimize(objective = objective, initial = 2, direction = "min")
optimizer$optimize(objective = objective, initial = 2, direction = "max")
Method print()
Prints the optimizer label.
Usage
Optimizer$print(...)
Arguments
...[
any]
Optionally additional named arguments to be passed to the optimizer algorithm. Without specifications, default values of the optimizer are used.
Returns
Invisibly the Optimizer object.
Method clone()
The objects of this class are cloneable with this method.
Usage
Optimizer$clone(deep = FALSE)
Arguments
deepWhether to make a deep clone.
Examples
### Task: compare minimization with 'stats::nlm' and 'pracma::nelder_mead'
# 1. define objective function and initial values
objective <- TestFunctions::TF_ackley
initial <- c(3, 3)
# 2. get overview of optimizers available in dictionary
optimizer_dictionary$keys
# 3. define 'nlm' optimizer
nlm <- Optimizer$new(which = "stats::nlm")
# 4. define the 'pracma::nelder_mead' optimizer (not contained in the dictionary)
nelder_mead <- Optimizer$new(which = "custom")
nelder_mead$definition(
algorithm = pracma::nelder_mead, # the optimization function
arg_objective = "fn", # the argument name for the objective function
arg_initial = "x0", # the argument name for the initial values
out_value = "fmin", # the element for the optimal function value in the output
out_parameter = "xmin", # the element for the optimal parameters in the output
direction = "min" # the optimizer minimizes
)
# 5. compare the minimization results
nlm$minimize(objective, initial)
nelder_mead$minimize(objective, initial)
## ------------------------------------------------
## Method `Optimizer$minimize`
## ------------------------------------------------
Optimizer$new("stats::nlm")$
minimize(objective = function(x) x^4 + 3*x - 5, initial = 2)
## ------------------------------------------------
## Method `Optimizer$maximize`
## ------------------------------------------------
Optimizer$new("stats::nlm")$
maximize(objective = function(x) -x^4 + 3*x - 5, initial = 2)
## ------------------------------------------------
## Method `Optimizer$optimize`
## ------------------------------------------------
objective <- function(x) -x^4 + 3*x - 5
optimizer <- Optimizer$new("stats::nlm")
optimizer$optimize(objective = objective, initial = 2, direction = "min")
optimizer$optimize(objective = objective, initial = 2, direction = "max")
R Package Documentation
Browse R Packages
We want your feedback!
Note that we can't provide technical support on individual packages. You should contact the package authors for that.
Embedding an R snippet on your website
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.