Expressions

@parameter_function(model::InfiniteModel, func_expr, kwargs...)

Add an anonymous parameter function to the model model described by the keyword arguments kw_args and returns the object reference.

@parameter_function(model::InfiniteModel, var_expr == func_expr, kwargs...)

Add a parameter function to model described by the expression var_expr, the function expression func_expr, and the keyword arguments kwargs. The expression var_expr is used to define the parameter function references of the form varname[...] where the indexing matches the container syntax of other macros.

The expression func_expr determines the concrete Julia function that defines the behavior of parameter function and also specifies the infinite parameters it depends on. The accepted forms are:

• func(params...): where func is the function that takes supports of the infinite parameters params as input and outputs a scalar value.
• (params...) -> my_func_expr: where params are the infinite parameters and my_func_expr is the source code of the anonymous function.

The recognized keyword arguments in kwargs are the following:

• base_name: Sets the name prefix used to generate object names. It corresponds to the object name for scalar parameter function, otherwise, the object names are set to base_name[...] for each index ... of the axes axes.
• container: Specify the container type. Defaults to :Auto.

Examples

julia> @parameter_function(model, sin(t))
sin(t)

julia> func_vect = [sin, cos];

julia> @parameter_function(model, [i = 1:2] == func_vect[i](t))
2-element Array{GeneralVariableRef,1}:
 sin(t)
 cos(t)

julia> f(t_val, x_vals) = t_val + sum(x_vals)
f (generic function with 1 method)

julia> @parameter_function(model, pf == f(t, x))
pf(t, x)

julia> g(t_val, a; b = 0) = t_val + a + b
g (generic function with 1 method)

julia> @parameter_function(model, pf2[i = 1:2] == t -> g(t, i, b = 2 * i ))
2-element Array{GeneralVariableRef,1}:
 pf2[1](t)
 pf2[2](t)

parameter_function(func::Function, 
                   pref_inputs::Union{GeneralVariableRef, AbstractArray{GeneralVariableRef}, Tuple}; 
                   [name::String = [the name of `func`]]
                   )::GeneralVariableRef

Make a parameter function and return a GeneralVariableRef that can be embedded in InfiniteOpt expressions. This serves as a convenient wrapper for build_parameter_function and add_parameter_function. For an even more convenient definition method see @parameter_function.

Here func denotes the function that will take a support of infinite parameters as input (formatted like pref_inputs) and will return a scalar value. Specifically, func should be of the form:

func(paramvals...)::Float64

where the formatting of paramvals is analagous to point variables (and will be based on the tuple of infinite parameter references given in parameter_refs). Moreover, func must be a function that returns a scalar numeric value.

Errors if func will not take a support formatted like pref_inputs in combination with the fargs and fkwargs specified. Also errors if pref_inputs follow an invalid input format.

Example

julia> p_func = parameter_function(sin, t)
sin(t)

julia> p_func3 = parameter_function((t_supp) -> 2 * sin(2 * t_supp), t, name = "mysin")
mysin(t)

julia> p_func4 = parameter_function(t, name = "mysin") do t_supp
                    if t_supp <= 5
                        return sin(t_supp)
                    else 
                        return 2 * sin(2 * t_supp)
                    end
                 end

mysin(t)

build_parameter_function(
    _error::Function, 
    func::Function, 
    parameter_refs::Union{GeneralVariableRef, AbstractArray{<:GeneralVariableRef}, Tuple}
    )::ParameterFunction

Build an ParameterFunction object that employs a parameter function func that takes instances of the infinite parameter(s) as input. This can ultimately by incorporated into expressions to enable nonlinear infinite parameter behavior and/or incorporate data over infinite domains.

Here func should be of the form:

func(paramvals...)::Float64

where the formatting of paramvals is analagous to point variables (and will be based on the tuple of infinite parameter references given in parameter_refs).

Errors if the infinite parameter tuple is formatted incorrectly. The allowed format follows that of infinite variables. Also errors if the function doesn't accept a support realization of the parameter_refs as input.

Example

julia> f = build_parameter_function(error, sin, t);

ParameterFunction{F <: Function, VT <: VectorTuple}

A DataType for storing known functions of infinite parameters. These equate to arbitrary functions that take support instances of infinite parameters parameter_refs in as input and compute a scalar value as output via func. These can then can incorporated in expressions via ParameterFunctionRefs.

Fields

• func::F: The function the takes infinite parameters as input and provide a scalar number as output.
• parameter_refs::VT: The infinite parameter references that serve as inputs to func. Their formatting is analagous to those of infinite variables.
• parameter_nums::Vector{Int}: The parameter numbers of parameter_refs.
• object_nums::Vector{Int}: The parameter object numbers associated with parameter_refs.

add_parameter_function(model::InfiniteModel, pfunc::ParameterFunction, 
                       [name::String])::GeneralVariableRef

Add an ParameterFunction pfunc to the model using name for printing and return a GeneralVariableRef such that it can be embedded in expressions. Errors if the parameter function pfunc points to do not belong to model. Note that pfunc should be created using build_parameter_function.

Example

julia> f = build_parameter_function(error, sin, t);

julia> fref = add_parameter_function(model, f)
sin(t)

ParameterFunctionData{F <: ParameterFunction} <: AbstractDataObject

A mutable DataType for storing ParameterFunctions and their data.

Fields

• func::F: The parameter function.
• name::String: The name used for printing.
• measure_indices::Vector{MeasureIndex}: Indices of dependent measures.
• constraint_indices::Vector{InfOptConstraintIndex}: Indices of dependent constraints.
• semi_infinite_var_indices::Vector{SemiInfiniteVariableIndex}: Indices of dependent semi-infinite variables.
• derivative_indices::Vector{DerivativeIndex}: Indices of dependent derivatives.

ParameterFunctionIndex <: ObjectIndex

A DataType for storing the index of a ParameterFunction.

Fields

• value::Int64: The index value.

ParameterFunctionRef <: DispatchVariableRef

A DataType for infinite parameter function references.

Fields

• model::InfiniteModel: Infinite model.
• index::ParameterFunctionIndex: Index of the infinite parameter function.

JuMP.name(fref::ParameterFunctionRef)::String

Extend JuMP.name to return the base name of fref.

Example

julia> name(fref)
"func_name"

raw_function(fref::ParameterFunctionRef)::Function

Returns the raw function behind fref that takes a particular support of fref's infinite parameters as input.

call_function(fref::ParameterFunctionRef, support...)::Float64

Safely evaluates the raw_function of fref at a particular support support point that matches the format of the infinite parameter tuple given when the fref was defined. This is essentially equivalent to raw_function(fref)(supps...).

call_function(fref::GeneralVariableRef, support...)::Float64

Call the parameter function of fref at support. An ArgumentError is thrown if fref is not a parameter function.

parameter_refs(fref::ParameterFunctionRef)::Tuple

Return the parameter references associated with fref. This is formatted as a Tuple of containing the parameter references as they inputted to define fref.

Example

julia> parameter_refs(p_func)
(t,)

parameter_list(fref::ParameterFunctionRef)::Vector{GeneralVariableRef}

Return a vector of the parameter references that fref depends on. This is primarily an internal method where parameter_refs is intended as the preferred user function.

raw_parameter_refs(fref::ParameterFunctionRef)::VectorTuple

Return the raw VectorTuple of the parameter references that fref depends on. This is primarily an internal method where parameter_refs is intended as the preferred user function.

is_used(fref::ParameterFunctionRef)::Bool

Return a Bool indicating if fref is used in the model.

Example

julia> is_used(fref)
true

used_by_semi_infinite_variable(fref::ParameterFunctionRef)::Bool

Return a Bool indicating if fref is used by a semi-infinite infinite variable.

Example

julia> used_by_semi_infinite_variable(fref)
false

used_by_derivative(fref::ParameterFunctionRef)::Bool

Return a Bool indicating if fref is used by a derivative.

Example

julia> used_by_derivative(vref)
true

used_by_measure(fref::ParameterFunctionRef)::Bool

Return a Bool indicating if fref is used by a measure.

Example

julia> used_by_measure(fref)
true

used_by_constraint(fref::ParameterFunctionRef)::Bool

Return a Bool indicating if fref is used by a constraint.

Example

julia> used_by_constraint(fref)
false

JuMP.set_name(fref::ParameterFunctionRef, name::String)::Nothing

Extend JuMP.set_name to set the name of a parameter function.

Example

julia> set_name(fref, "func_name")

julia> name(fref)
"func_name"

JuMP.delete(model::InfiniteModel, fref::ParameterFunctionRef)::Nothing

Extend JuMP.delete to delete parameter functions and their dependencies. Errors if fref is invalid, meaning it has already been deleted or it belongs to another model.

NodeData

A DataType for storing values in an expression tree that is used in a NLPExpr. Acceptable value types include:

• Real: Constants
• GeneralVariableRef: Optimization variables
• JuMP.GenericAffExpr{Float64, GeneralVariableRef}: Affine expressions
• JuMP.GenericQuadExpr{Float64, GeneralVariableRef}: Quadratic expressions
• Symbol: Registered NLP function name.

Fields

• value: The stored value.

NLPExpr <: JuMP.AbstractJuMPScalar

A DataType for storing scalar nonlinear expressions. It stores the expression algebraically via an expression tree where each node contains NodeData that can store one of the following:

• a registered function name (stored as a Symbol)
• a constant
• a variable
• an affine expression
• a quadratic expression.

Specifically, it employs a left-child right-sibling tree (from LeftChildRightSiblingTrees.jl) to represent the expression tree.

Fields

• tree_root::LeftChildRightSiblingTrees.Node{NodeData}: The root node of the expression tree.

RegisteredFunction{F <: Function, G <: Union{Function, Nothing}, 
                   H <: Union{Function, Nothing}}

A type for storing used defined registered functions and their information that is needed by JuMP for build an NLPEvaluator. The constructor is of the form:

    RegisteredFunction(name::Symbol, num_args::Int, func::Function, 
                       [gradient::Function, hessian::Function])

Fields

• name::Symbol: The name of the function that is used in NLPExprs.
• num_args::Int: The number of function arguments.
• func::F: The function itself.
• gradient::G: The gradient function if one is given.
• hessian::H: The hessian function if one is given.

@register(model::InfiniteModel, func_expr, [gradient::Function], [hessian::Function])

Register a user-defined function in accordance with func_expr such that it can be used in NLPExprs that are used with model without being traced.

Argument Information Here func_expr is of the form: myfunc(a, b) where myfunc is the function name and the number of arguments are given symbolically. Note that the choice of argument symbols is arbitrary. Each function argument must support anything of type Real to specified.

Here we can also specify a gradient function gradient which for 1 argument functions must taken in the 1 argument and return its derivative. For multi-argument functions the gradient function must be of the form:

function gradient(g::AbstractVector{T}, args::T...) where {T <: Real}
    # fill g vector with the gradient of the function
end

For 1 argument functions we can also specify a hessian function with takes that argument and return the 2nd derivative. Hessians can ge specified for multi-argument functions, but JuMP backends do not currently support this.

If no gradient and/or hessian is given, the automatic differentation capabilities of the backend (e.g., JuMP) will be used to determine them. Note that the JuMP backend does not use Hessian's for user-defined multi-argument functions.

Notes

• When possible, tracing is preferred over registering a function (see Function Tracing for more info).
• Only user-defined functions can be specified. If the function is used by a package then it can not be used directly. However, we can readily wrap it in a new function newfunc(a) = pkgfunc(a).
• We can only register functions in the same scope that they are defined in.
• Registered functions can only be used in or below the scope in which they are registered. For instance, if we register some function inside of another function then we can only use it inside that function (not outside of it).
• A function with a given name and number of arguments can only be registered once in a particular model.

Examples

julia> @variable(model, x)
x

julia> f(a) = a^3;

julia> f(x) # user-function gets traced
x^3

julia> @register(model, f(a)) # register function
f (generic function with 2 methods)

julia> f(x) # function is no longer traced and autodifferentiation will be used
f(x)

julia> f2(a) = a^2; g2(a) = 2 * a; h2(a) = 2;

julia> @register(model, f2(a), g2, h2) # register with explicit gradient and hessian
f2 (generic function with 2 methods)

julia> f2(x)
f2(x)

julia> f3(a, b) = a * b^2;

julia> function g3(v, a, b)
          v[1] = b^2
          v[2] = 2 * a * b
          return
       end;

julia> @register(model, f3(a, b), g3) # register multi-argument function
f3 (generic function with 4 methods)

julia> f3(42, x)
f3(42, x)

all_registered_functions(model::InfiniteModel)::Vector{Function}

Retrieve all the functions that are currently registered to model.

name_to_function(model::InfiniteModel, name::Symbol, num_args::Int)::Union{Function, Nothing}

Return the registered function that corresponds to name with num_args. Returns nothing if no such registered function exists. This helps retrieve the functions of function names stored in NLPExprs.

user_registered_functions(model::InfiniteModel)::Vector{RegisteredFunction}

Return all the functions (and their associated information) that the user has registered to model. Each is stored as a RegisteredFunction.

InfiniteOpt.ifelse(cond::NLPExpr, v1::Union{AbstractInfOptExpr, Real}, 
                   v2::Union{AbstractInfOptExpr, Real})::NLPExpr

A symbolic version of Core.ifelse that can be used to establish symbolic expressions with logic conditions. Note that is must be written InfiniteOpt.ifelse since it conflicts with Core.ifelse.

Example

julia> InfiniteOpt.ifelse(x >= y, 0, y^3)
ifelse(x >= y, 0, y^3)

print_expression_tree(nlp::NLPExpr)

Print a tree representation of the nonlinear expression nlp.

Example

julia> expr = (x * sin(x)^3) / 2
(x * sin(x)^3) / 2

julia> print_expression_tree(expr)
/
├─ *
│  ├─ x
│  └─ ^
│     ├─ sin
│     │  └─ x
│     └─ 3
└─ 2

JuMP.drop_zeros!(nlp::NLPExpr)::NLPExpr

Removes the zeros (possibly introduced by deletion) from an nonlinear expression. Note this only uses a few simple heuristics and will not remove more complex relationships like cos(π/2).

Example

julia> expr = x^2.3 * max(0, zero(NLPExpr)) - exp(1/x + 0)
x^2.3 * max(0, 0) - exp(1 / x + 0)

julia> drop_zeros!(expr)
-exp(1 / x)

map_nlp_to_ast(map_func::Function, nlp::NLPExpr)::Expr

Map the nonlinear expression nlp to a Julia AST expression where each variable is mapped via map_func and is directly interpolated into the AST expression. This is intended as an internal method that can be helpful for developers that wish to map a NLPExpr to a Julia AST expression that is compatible with JuMP.add_NL_expression.

add_registered_to_jump(opt_model::JuMP.Model, inf_model::InfiniteModel)::Nothing

Add the user registered functions in inf_model to a JuMP model opt_model. This is intended as an internal method, but it is provided for developers that extend InfiniteOpt to use other optimizer models.

parameter_refs(expr)::Tuple

Return the tuple of parameter references that determine the infinite dependencies of expr.

Example

julia> parameter_refs(my_expr)
(t,)

map_expression(transform::Function, 
               expr::JuMP.AbstractJuMPScalar)::JuMP.AbstractJuMPScalar

Map and return a new expression of expr where each variable is transformed via transform. This can be helpful for writing user extensions.

GeneralVariableRef <: JuMP.AbstractVariableRef

A DataType that serves as the principal variable reference in InfiniteOpt for building variable expressions. It contains the needed information to create a variable type specifc reference (e.g., InfiniteVariableRef) via dispatch_variable_ref to obtain the correct subtype of DispatchVariableRef based off of index_type. This allows us to construct expressions using concrete containers unlike previous versions of InfiniteOpt which provides us a significant performance boost.

Fields

• model::InfiniteModel: Infinite model.
• raw_index::Int64: The raw index to be used in the index_type constructor.
• index_type::DataType: The concrete AbstractInfOptIndex type/constructor.
• param_index::Int: The index of a parameter in DependentParameters. This is ignored for other variable types.

DispatchVariableRef <: JuMP.AbstractVariableRef

An abstract type for variable references that are created from GeneralVariableRefs and are used to dispatch to the appropriate methods for that particular variable/parameter/measure type.

FiniteRef <: DispatchVariableRef

An abstract type for variable references that are finite.

JuMP.owner_model(vref::GeneralVariableRef)::InfiniteModel

Extend JuMP.owner_model to return the model where vref is stored.

Example

julia> owner_model(vref)
An InfiniteOpt Model
Feasibility problem with:
Finite Parameters: 0
Infinite Parameters: 0
Variable: 1
Derivatives: 0
Measures: 0
`FiniteVariableRef`-in-`MathOptInterface.GreaterThan{Float64}`: 1 constraint
`FiniteVariableRef`-in-`MathOptInterface.LessThan{Float64}`: 1 constraint
Names registered in the model: vref
Optimizer model backend information:
Model mode: AUTOMATIC
CachingOptimizer state: NO_OPTIMIZER
Solver name: No optimizer attached.

JuMP.owner_model(vref::DispatchVariableRef)::InfiniteModel

Extend JuMP.owner_model to return the model where vref is stored.

JuMP.index(vref::GeneralVariableRef)::AbstractInfOptIndex

Extend JuMP.index to return the appropriate index of vref.

Example

julia> index(vref)
FiniteVariableIndex(1)

JuMP.index(vref::DispatchVariableRef)::AbstractInfOptIndex

Extend JuMP.index to return the appropriate index of vref.

dispatch_variable_ref(vef::GeneralVariableRef)::DispatchVariableRef

Return the concrete DispatchVariableRef this associated with vref. This relies on dispatch_variable_ref being extended for the index type, otherwise an MethodError is thrown.

dispatch_variable_ref(model::InfiniteModel, index::AbstractInfOptIndex)

Return the variable reference associated the type of index. This needs to be defined for each variable reference type.

JuMP.name(vref::GeneralVariableRef)::String

Extend JuMP.name to return the name of vref. It relies on JuMP.name being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown.

JuMP.set_name(vref::GeneralVariableRef, name::String)::Nothing

Extend JuMP.set_name to set the name of vref. It relies on JuMP.set_name being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown.

JuMP.is_valid(model::InfiniteModel, vref::GeneralVariableRef)::Bool

Extend JuMP.is_valid to return Bool if vref is a valid reference.

Example

julia> is_valid(model, vref)
true

JuMP.is_valid(model::InfiniteModel, vref::DispatchVariableRef)::Bool

Extend JuMP.is_valid to return Bool if vref is a valid reference.

used_by_infinite_variable(vref::GeneralVariableRef)::Bool

Define used_by_infinite_variable for general variable references. It relies on used_by_infinite_variable being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

used_by_point_variable(vref::GeneralVariableRef)::Bool

Define used_by_point_variable for general variable references. It relies on used_by_point_variable being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

used_by_semi_infinite_variable(vref::GeneralVariableRef)::Bool

Define used_by_semi_infinite_variable for general variable references. It relies on used_by_semi_infinite_variable being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

used_by_derivative(vref::GeneralVariableRef)::Bool

Define used_by_derivative for general variable references. It relies on used_by_derivative being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

used_by_measure(vref::GeneralVariableRef)::Bool

Define used_by_measure for general variable references. It relies on used_by_measure being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

used_by_objective(vref::GeneralVariableRef)::Bool

Define used_by_objective for general variable references. It relies on used_by_objective being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

used_by_constraint(vref::GeneralVariableRef)::Bool

Define used_by_constraint for general variable references. It relies on used_by_constraint being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

is_used(vref::GeneralVariableRef)::Bool

Define is_used for general variable references. It relies on is_used being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

has_derivative_constraints(vref::GeneralVariableRef)::Bool

Define has_derivative_constraints for general variable references. It relies on has_derivative_constraints being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

parameter_value(prefs; [kwargs...])

Define parameter_value for general variable references. It relies on parameter_value being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

JuMP.set_value(vref::DispatchVariableRef, value::Real)::Nothing

Extend JuMP.set_value to set the value of vref. It relies on JuMP.set_value being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown.

infinite_domain(prefs; [kwargs...])

Define infinite_domain for general variable references. It relies on infinite_domain being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

infinite_domain(prefs; [kwargs...])

Define infinite_domain for general variable references. It relies on infinite_domain being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

set_infinite_domain(pref::GeneralVariableRef, domain::InfiniteScalarDomain)::Nothing

Specify the scalar infinite domain of the infinite parameter pref to domain. Note this will reset/delete all the supports contained in the underlying parameter object. Also, errors if pref is used by a measure. An ArgumentError is thrown if pref is not an infinite parameter.

set_infinite_domain(prefs::AbstractArray{<:GeneralVariableRef},
                 domain::InfiniteArrayDomain)::Nothing

Specify the multi-dimensional infinite domain of the dependent infinite parameters prefs to domain. Note this will reset/delete all the supports contained in the underlying DependentParameters object. This will error if the not all of the dependent infinite parameters are included or if any of them are used by measures. An ArgumentError is thrown if prefs are not dependent infinite parameters.

num_supports(prefs; [kwargs...])

Define num_supports for general variable references. It relies on num_supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

num_supports(prefs; [kwargs...])

Define num_supports for general variable references. It relies on num_supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

has_supports(prefs; [kwargs...])

Define has_supports for general variable references. It relies on has_supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

has_supports(prefs; [kwargs...])

Define has_supports for general variable references. It relies on has_supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

supports(expr::JuMP.AbstractJuMPScalar; 
         [label::Type{<:AbstractSupportLabel} = PublicLabel,
         ndarray::Bool = false,
         kwargs...])

Return the support associated with expr. Errors if expr is not associated with the constraint mappings stored in optimizer_model.

The keyword arugments label and ndarray are what TranscriptionOpt employ and kwargs denote extra ones that user extensions may employ in accordance with their implementation of expression_supports. Errors if such an extension has not been written.

By default only the public supports are returned, the full set can be accessed via label = All. Moreover, the supports of infinite expressions are returned as a list. However, a n-dimensional array can be obtained via ndarray = true which is handy when the expression has multiple infinite parameter dependencies.

Example

julia> supports(cref)
2-element Array{Tuple{Float64},1}:
 (0.0,)
 (1.0,)

supports(prefs; [kwargs...])

Define supports for general variable references. It relies on supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

supports(prefs; [kwargs...])

Define supports for general variable references. It relies on supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

set_supports(pref::GeneralVariableRef, supports::Union{Real, Vector{<:Real}};
             [force::Bool = false])::Nothing

Set the support points associated with a single infinite parameter pref. An ArgumentError is thrown if pref is not an independent infinite parameter.

set_supports(
    prefs::Union{Vector{GeneralVariableRef}, AbstractArray{<:GeneralVariableRef}},
    supports::Union{Array{<:Real, 2}, Vector{<:AbstractArray{<:Real}}};
    [force::Bool = false]
    )::Nothing

Set the support points associated with dependent infinite parameters prefs. An ArgumentError is thrown if prefs is are not dependent infinite parameters.

add_supports(pref::GeneralVariableRef,
             supports::Union{Real, Vector{<:Real}})::Nothing

Add the support points supports to a single infinite parameter pref. An ArgumentError is thrown if pref is not an independent infinite parameter.

add_supports(
    prefs::Union{Vector{GeneralVariableRef}, AbstractArray{<:GeneralVariableRef}},
    supports::Union{Array{<:Real, 2}, Vector{<:AbstractArray{<:Real}}}
    )::Nothing

Add the support points supports to the dependent infinite parameters prefs. An ArgumentError is thrown if prefs is are not dependent infinite parameters.

delete_supports(prefs; [kwargs...])

Define delete_supports for general variable references. It relies on delete_supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

delete_supports(prefs; [kwargs...])

Define delete_supports for general variable references. It relies on delete_supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

fill_in_supports!(prefs; [kwargs...])

Define fill_in_supports! for general variable references. It relies on fill_in_supports! being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

fill_in_supports!(prefs; [kwargs...])

Define fill_in_supports! for general variable references. It relies on fill_in_supports! being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

raw_parameter_refsc(vref::GeneralVariableRef)

Define raw_parameter_refs for general variable references. It relies on raw_parameter_refs being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

parameter_refsc(vref::GeneralVariableRef)

Define parameter_refs for general variable references. It relies on parameter_refs being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

parameter_listc(vref::GeneralVariableRef)

Define parameter_list for general variable references. It relies on parameter_list being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

raw_function(prefs; [kwargs...])

Define raw_function for general variable references. It relies on raw_function being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

infinite_variable_refc(vref::GeneralVariableRef)

Define infinite_variable_ref for general variable references. It relies on infinite_variable_ref being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

eval_supportsc(vref::GeneralVariableRef)

Define eval_supports for general variable references. It relies on eval_supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

raw_parameter_valuesc(vref::GeneralVariableRef)

Define raw_parameter_values for general variable references. It relies on raw_parameter_values being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

parameter_valuesc(vref::GeneralVariableRef)

Define parameter_values for general variable references. It relies on parameter_values being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

significant_digits(prefs; [kwargs...])

Define significant_digits for general variable references. It relies on significant_digits being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

measure_function(mref::GeneralVariableRef)

Define measure_function for general variable references. Errors if mref does not correspond to a MeasureRef. See the underlying docstrings for more information.

measure_data(mref::GeneralVariableRef)

Define measure_data for general variable references. Errors if mref does not correspond to a MeasureRef. See the underlying docstrings for more information.

is_analytic(mref::GeneralVariableRef)

Define is_analytic for general variable references. Errors if mref does not correspond to a MeasureRef. See the underlying docstrings for more information.

derivative_argument(dref::GeneralVariableRef)

Define derivative_argument for general variable references. Errors if dref does not correspond to a DerivativeRef. See the underlying docstrings for more information.

operator_parameter(dref::GeneralVariableRef)

Define operator_parameter for general variable references. Errors if dref does not correspond to a DerivativeRef. See the underlying docstrings for more information.

derivative_method(prefs; [kwargs...])

Define derivative_method for general variable references. It relies on derivative_method being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

evaluate(dref::GeneralVariableRef)

Define evaluate for general variable references. Errors if dref does not correspond to a DerivativeRef. See the underlying docstrings for more information.

derivative_constraints(dref::GeneralVariableRef)

Define derivative_constraints for general variable references. Errors if dref does not correspond to a DerivativeRef. See the underlying docstrings for more information.

delete_derivative_constraints(dref::GeneralVariableRef)

Define delete_derivative_constraints for general variable references. Errors if dref does not correspond to a DerivativeRef. See the underlying docstrings for more information.

add_generative_supports(prefs; [kwargs...])

Define add_generative_supports for general variable references. It relies on add_generative_supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

set_derivative_method(pref::GeneralVariableRef,
                      method::AbstractDerivativeMethod
                      )::Nothing

Specify the numerical derivative evaluation technique associated with pref. An ArgumentError is thrown if pref is not an infinite parameter.

has_generative_supports(prefs; [kwargs...])

Define has_generative_supports for general variable references. It relies on has_generative_supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

has_internal_supports(prefs; [kwargs...])

Define has_internal_supports for general variable references. It relies on has_internal_supports being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information. Note that this is a auto generated wrapper and the underlying method may or may not use kwargs.

JuMP.delete(model::InfiniteModel, vref::GeneralVariableRef)::Nothing

Extend JuMP.delete to delete vref and its dependencies. It relies on JuMP.delete being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown.

JuMP.delete(model::InfiniteModel,
            prefs::AbstractArray{<:GeneralVariableRef})::Nothing

Extend JuMP.delete to delete a group of dependent infinite parameters and their dependencies. An ArgumentError is thrown if prefs are not dependent infinite parameters.

JuMP.has_lower_bound(vref::GeneralVariableRef)

Define JuMP.has_lower_bound for general variable references. It relies on JuMP.has_lower_bound being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.lower_bound(vref::GeneralVariableRef)

Define JuMP.lower_bound for general variable references. It relies on JuMP.lower_bound being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.set_lower_bound(vref::GeneralVariableRef, value::Real)::Nothing

Define JuMP.set_lower_bound for general variable references. It relies on JuMP.set_lower_bound being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.LowerBoundRef(vref::GeneralVariableRef)

Define JuMP.LowerBoundRef for general variable references. It relies on JuMP.LowerBoundRef being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.delete_lower_bound(vref::GeneralVariableRef)

Define JuMP.delete_lower_bound for general variable references. It relies on JuMP.delete_lower_bound being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.has_upper_bound(vref::GeneralVariableRef)

Define JuMP.has_upper_bound for general variable references. It relies on JuMP.has_upper_bound being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.upper_bound(vref::GeneralVariableRef)

Define JuMP.upper_bound for general variable references. It relies on JuMP.upper_bound being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.set_upper_bound(vref::GeneralVariableRef, value::Real)::Nothing

Define JuMP.set_upper_bound for general variable references. It relies on JuMP.set_upper_bound being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.UpperBoundRef(vref::GeneralVariableRef)

Define JuMP.UpperBoundRef for general variable references. It relies on JuMP.UpperBoundRef being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.delete_upper_bound(vref::GeneralVariableRef)

Define JuMP.delete_upper_bound for general variable references. It relies on JuMP.delete_upper_bound being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.is_fixed(vref::GeneralVariableRef)

Define JuMP.is_fixed for general variable references. It relies on JuMP.is_fixed being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.fix_value(vref::GeneralVariableRef)

Define JuMP.fix_value for general variable references. It relies on JuMP.fix_value being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.fix(vref::GeneralVariableRef, value::Real; force::Bool = false)::Nothing

Define JuMP.fix for general variable references. It relies on JuMP.fix being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.FixRef(vref::GeneralVariableRef)

Define JuMP.FixRef for general variable references. It relies on JuMP.FixRef being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.unfix(vref::GeneralVariableRef)

Define JuMP.unfix for general variable references. It relies on JuMP.unfix being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.start_value(vref::GeneralVariableRef)

Define JuMP.start_value for general variable references. It relies on JuMP.start_value being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.set_start_value(vref::GeneralVariableRef, value::Real)::Nothing

Define JuMP.set_start_value for general variable references. It relies on JuMP.set_start_value being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

start_value_functionc(vref::GeneralVariableRef)

Define start_value_function for general variable references. It relies on start_value_function being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

set_start_value_function(vref::GeneralVariableRef, start::Union{Real, Function})::Nothing

Set the start value function of vref. It relies on set_start_value_function being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown.

reset_start_value_functionc(vref::GeneralVariableRef)

Define reset_start_value_function for general variable references. It relies on reset_start_value_function being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.is_binary(vref::GeneralVariableRef)

Define JuMP.is_binary for general variable references. It relies on JuMP.is_binary being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.set_binary(vref::GeneralVariableRef)

Define JuMP.set_binary for general variable references. It relies on JuMP.set_binary being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.BinaryRef(vref::GeneralVariableRef)

Define JuMP.BinaryRef for general variable references. It relies on JuMP.BinaryRef being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.unset_binary(vref::GeneralVariableRef)

Define JuMP.unset_binary for general variable references. It relies on JuMP.unset_binary being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.is_integer(vref::GeneralVariableRef)

Define JuMP.is_integer for general variable references. It relies on JuMP.is_integer being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.set_integer(vref::GeneralVariableRef)

Define JuMP.set_integer for general variable references. It relies on JuMP.set_integer being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.IntegerRef(vref::GeneralVariableRef)

Define JuMP.IntegerRef for general variable references. It relies on JuMP.IntegerRef being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

JuMP.unset_integer(vref::GeneralVariableRef)

Define JuMP.unset_integer for general variable references. It relies on JuMP.unset_integer being defined for the underlying DispatchVariableRef, otherwise an ArgumentError is thrown. See the underlying docstrings for more information.

_add_data_object(model::InfiniteModel, object::AbstractDataObject)::ObjectIndex

Add object to the appropriate CleverDict in model and return the its index. This needs to be defined for the type of object. These definitions need to use MOIUC.add_item to add the object to the CleverDict.

_data_dictionary(vref::DispatchVariableRef)::MOIUC.CleverDict

Return the CleverDict that stores data objects for the type of vref. This needs to be defined for the type of vref.

_data_object(vref::DispatchVariableRef)::AbstractDataObject

Return the data object associated with vref, in other words the object its index points to in the InfiniteModel. This needs to be defined for the type of vref. This should use _data_dictionary to access the CleverDict that the object is stored in.

_delete_data_object(vref::DispatchVariableRef)::Nothing

Delete the concrete AbstractDataObject associated with vref.

_core_variable_object(vref::DispatchVariableRef)::Union{InfOptParameter, InfOptVariable, Measure}

Return the core object that vref points to. This needs to be extended for type of vref. This should use _data_object to access the data object where the variable object is stored.

_core_variable_object(vref::GeneralVariableRef)::Union{InfOptParameter, InfOptVariable, Measure}

Return the core object that vref points to. This is enabled with appropriate definitions of _core_variable_object for the underlying DispatchVariableRef, otherwise an MethodError is thrown.

_set_core_variable_object(vref::DispatchVariableRef, object)::Nothing

Sets the core object that vref points to object. This needs to be extended for types of vref and object. This should use _data_object to access the data object where the variable object is stored.

_infinite_variable_dependencies(vref::DispatchVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This needs to be extended for type of vref. This should use _data_object to access the data object where the name is stored if appropriate.

_infinite_variable_dependencies(vref::GeneralVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This is enabled with appropriate definitions of _infinite_variable_dependencies for the underlying DispatchVariableRef, otherwise an MethodError is thrown.

_semi_infinite_variable_dependencies(vref::DispatchVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This needs to be extended for type of vref. This should use _data_object to access the data object where the name is stored if appropriate.

_semi_infinite_variable_dependencies(vref::GeneralVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This is enabled with appropriate definitions of _semi_infinite_variable_dependencies for the underlying DispatchVariableRef, otherwise an MethodError is thrown.

_point_variable_dependencies(vref::DispatchVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This needs to be extended for type of vref. This should use _data_object to access the data object where the name is stored if appropriate.

_point_variable_dependencies(vref::GeneralVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This is enabled with appropriate definitions of _point_variable_dependencies for the underlying DispatchVariableRef, otherwise an MethodError is thrown.

_derivative_dependencies(vref::DispatchVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This needs to be extended for type of vref. This should use _data_object to access the data object where the name is stored if appropriate.

_derivative_dependencies(vref::GeneralVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This is enabled with appropriate definitions of _derivative_dependencies for the underlying DispatchVariableRef, otherwise an MethodError is thrown.

_measure_dependencies(vref::DispatchVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This needs to be extended for type of vref. This should use _data_object to access the data object where the name is stored if appropriate.

_measure_dependencies(vref::GeneralVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This is enabled with appropriate definitions of _measure_dependencies for the underlying DispatchVariableRef, otherwise an MethodError is thrown.

_generative_measures(vref::DispatchVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This needs to be extended for type of vref. This should use _data_object to access the data object where the name is stored if appropriate.

_generative_measures(vref::GeneralVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This is enabled with appropriate definitions of _generative_measures for the underlying DispatchVariableRef, otherwise an MethodError is thrown.

_constraint_dependencies(vref::DispatchVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This needs to be extended for type of vref. This should use _data_object to access the data object where the name is stored if appropriate.

_constraint_dependencies(vref::GeneralVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This is enabled with appropriate definitions of _constraint_dependencies for the underlying DispatchVariableRef, otherwise an MethodError is thrown.

_derivative_constraint_dependencies(vref::DispatchVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This needs to be extended for type of vref. This should use _data_object to access the data object where the name is stored if appropriate.

_derivative_constraint_dependencies(vref::GeneralVariableRef)::Vector{AbstractInfOptIndex}

Return the indices of these entities that depend on vref. This is enabled with appropriate definitions of _derivative_constraint_dependencies for the underlying DispatchVariableRef, otherwise an MethodError is thrown.

_parameter_number(pref::DispatchVariableRef)::Int

Return the parameter creation number for pref assuming it is an infinite parameter. This needs to be defined for the type of pref. This should use the _data_object to get the number.

_parameter_number(pref::GeneralVariableRef)::Int

Return the parameter creation number for pref assuming it is an infinite parameter. It relies on _parameter_number being properly defined for the underlying DispatchVariableRef, otherwise an MethodError is thrown.

_object_number(pref::DispatchVariableRef)::Int

Return the object number for pref assuming it is an infinite parameter. This needs to be defined for the type of pref. This should use the _data_object to get the number.

_object_number(pref::GeneralVariableRef)::Int

Return the object number for pref assuming it is an infinite parameter. It relies on _object_number being properly defined for the underlying DispatchVariableRef, otherwise an MethodError is thrown.