Expressions

A technical manual for variable expressions in InfiniteOpt. See the respective guide for more information.

Parameter Functions

Definition

InfiniteOpt.@parameter_functionMacro
@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)
source
InfiniteOpt.parameter_functionFunction
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)
source
InfiniteOpt.build_parameter_functionFunction
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);
source
InfiniteOpt.ParameterFunctionType
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.
source
InfiniteOpt.add_parameter_functionFunction
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)
source
InfiniteOpt.ParameterFunctionDataType
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.
source
InfiniteOpt.ParameterFunctionRefType
ParameterFunctionRef <: DispatchVariableRef

A DataType for infinite parameter function references.

Fields

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

Queries

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

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

Example

julia> name(fref)
"func_name"
source
InfiniteOpt.raw_functionMethod
raw_function(fref::ParameterFunctionRef)::Function

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

source
InfiniteOpt.call_functionFunction
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...).

source
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.

source
InfiniteOpt.parameter_refsMethod
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,)
source
InfiniteOpt.parameter_listMethod
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.

source
InfiniteOpt.is_usedMethod
is_used(fref::ParameterFunctionRef)::Bool

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

Example

julia> is_used(fref)
true
source
InfiniteOpt.used_by_semi_infinite_variableMethod
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
source
InfiniteOpt.used_by_derivativeMethod
used_by_derivative(fref::ParameterFunctionRef)::Bool

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

Example

julia> used_by_derivative(vref)
true
source
InfiniteOpt.used_by_measureMethod
used_by_measure(fref::ParameterFunctionRef)::Bool

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

Example

julia> used_by_measure(fref)
true
source
InfiniteOpt.used_by_constraintMethod
used_by_constraint(fref::ParameterFunctionRef)::Bool

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

Example

julia> used_by_constraint(fref)
false
source

Modification

JuMP.set_nameMethod
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"
source
JuMP.deleteMethod
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.

source

Nonlinear Expressions

DataTypes

InfiniteOpt.NodeDataType
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.
source
InfiniteOpt.NLPExprType
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.
source
InfiniteOpt.RegisteredFunctionType
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.
source

Methods/Macros

InfiniteOpt.@registerMacro
@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)
source
InfiniteOpt.name_to_functionFunction
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.

source
InfiniteOpt.ifelseFunction
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)
source
InfiniteOpt.print_expression_treeMethod
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
source
JuMP.drop_zeros!Method
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)
source
InfiniteOpt.map_nlp_to_astFunction
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.

source
InfiniteOpt.add_registered_to_jumpFunction
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.

source

Expression Methods

InfiniteOpt.parameter_refsMethod
parameter_refs(expr)::Tuple

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

Example

julia> parameter_refs(my_expr)
(t,)
source
InfiniteOpt.map_expressionFunction
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.

source

GeneralVariableRef User Methods

InfiniteOpt.GeneralVariableRefType
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.
source
InfiniteOpt.DispatchVariableRefType
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.

source
JuMP.owner_modelMethod
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.
source
JuMP.owner_modelMethod
JuMP.owner_model(vref::DispatchVariableRef)::InfiniteModel

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

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

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

Example

julia> index(vref)
FiniteVariableIndex(1)
source
JuMP.indexMethod
JuMP.index(vref::DispatchVariableRef)::AbstractInfOptIndex

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

source
InfiniteOpt.dispatch_variable_refMethod
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.

source
InfiniteOpt.dispatch_variable_refFunction
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.

source
JuMP.nameMethod
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.

source
JuMP.set_nameMethod
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.

source
JuMP.is_validMethod
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
source
JuMP.is_validMethod
JuMP.is_valid(model::InfiniteModel, vref::DispatchVariableRef)::Bool

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

source
InfiniteOpt.used_by_infinite_variableMethod
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.

source
InfiniteOpt.used_by_point_variableMethod
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.

source
InfiniteOpt.used_by_semi_infinite_variableMethod
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.

source
InfiniteOpt.used_by_derivativeMethod
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.

source
InfiniteOpt.used_by_measureMethod
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.

source
InfiniteOpt.used_by_objectiveMethod
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.

source
InfiniteOpt.used_by_constraintMethod
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.

source
InfiniteOpt.is_usedMethod
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.

source
InfiniteOpt.has_derivative_constraintsMethod
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.

source
InfiniteOpt.parameter_valueMethod
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.

source
JuMP.set_valueMethod
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.

source
InfiniteOpt.infinite_domainMethod
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.

source
InfiniteOpt.infinite_domainMethod
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.

source
InfiniteOpt.set_infinite_domainMethod
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.

source
InfiniteOpt.set_infinite_domainMethod
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.

source
InfiniteOpt.num_supportsMethod
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.

source
InfiniteOpt.num_supportsMethod
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.

source
InfiniteOpt.has_supportsMethod
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.

source
InfiniteOpt.has_supportsMethod
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.

source
InfiniteOpt.supportsMethod
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,)
source
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.

source
InfiniteOpt.supportsMethod
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.

source
InfiniteOpt.set_supportsMethod
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.

source
InfiniteOpt.set_supportsMethod
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.

source
InfiniteOpt.add_supportsMethod
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.

source
InfiniteOpt.add_supportsMethod
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.

source
InfiniteOpt.delete_supportsMethod
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.

source
InfiniteOpt.delete_supportsMethod
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.

source
InfiniteOpt.fill_in_supports!Method
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.

source
InfiniteOpt.fill_in_supports!Method
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.

source
InfiniteOpt.raw_parameter_refsMethod
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.

source
InfiniteOpt.parameter_refsMethod
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.

source
InfiniteOpt.parameter_listMethod
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.

source
InfiniteOpt.raw_functionMethod
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.

source
InfiniteOpt.infinite_variable_refMethod
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.

source
InfiniteOpt.eval_supportsMethod
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.

source
InfiniteOpt.raw_parameter_valuesMethod
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.

source
InfiniteOpt.parameter_valuesMethod
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.

source
InfiniteOpt.significant_digitsMethod
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.

source
InfiniteOpt.measure_functionMethod
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.

source
InfiniteOpt.measure_dataMethod
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.

source
InfiniteOpt.is_analyticMethod
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.

source
InfiniteOpt.derivative_argumentMethod
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.

source
InfiniteOpt.operator_parameterMethod
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.

source
InfiniteOpt.derivative_methodMethod
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.

source
InfiniteOpt.evaluateMethod
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.

source
InfiniteOpt.derivative_constraintsMethod
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.

source
InfiniteOpt.delete_derivative_constraintsMethod
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.

source
InfiniteOpt.add_generative_supportsMethod
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.

source
InfiniteOpt.set_derivative_methodMethod
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.

source
InfiniteOpt.has_generative_supportsMethod
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.

source
InfiniteOpt.has_internal_supportsMethod
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.

source
JuMP.deleteMethod
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.

source
JuMP.deleteMethod
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.

source
JuMP.has_lower_boundMethod
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.

source
JuMP.lower_boundMethod
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.

source
JuMP.set_lower_boundMethod
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.

source
JuMP.LowerBoundRefMethod
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.

source
JuMP.delete_lower_boundMethod
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.

source
JuMP.has_upper_boundMethod
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.

source
JuMP.upper_boundMethod
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.

source
JuMP.set_upper_boundMethod
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.

source
JuMP.UpperBoundRefMethod
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.

source
JuMP.delete_upper_boundMethod
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.

source
JuMP.is_fixedMethod
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.

source
JuMP.fix_valueMethod
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.

source
JuMP.fixMethod
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.

source
JuMP.FixRefMethod
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.

source
JuMP.unfixMethod
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.

source
JuMP.start_valueMethod
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.

source
JuMP.set_start_valueMethod
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.

source
InfiniteOpt.start_value_functionMethod
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.

source
InfiniteOpt.set_start_value_functionMethod
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.

source
InfiniteOpt.reset_start_value_functionMethod
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.

source
JuMP.is_binaryMethod
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.

source
JuMP.set_binaryMethod
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.

source
JuMP.BinaryRefMethod
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.

source
JuMP.unset_binaryMethod
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.

source
JuMP.is_integerMethod
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.

source
JuMP.set_integerMethod
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.

source
JuMP.IntegerRefMethod
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.

source
JuMP.unset_integerMethod
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.

source

Developer Internal Methods

InfiniteOpt._add_data_objectFunction
_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.

source
InfiniteOpt._data_dictionaryFunction
_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.

source
InfiniteOpt._data_objectFunction
_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.

source
InfiniteOpt._core_variable_objectFunction
_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.

source
InfiniteOpt._core_variable_objectMethod
_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.

source
InfiniteOpt._set_core_variable_objectFunction
_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.

source
InfiniteOpt._infinite_variable_dependenciesFunction
_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.

source
InfiniteOpt._infinite_variable_dependenciesMethod
_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.

source
InfiniteOpt._semi_infinite_variable_dependenciesFunction
_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.

source
InfiniteOpt._semi_infinite_variable_dependenciesMethod
_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.

source
InfiniteOpt._point_variable_dependenciesFunction
_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.

source
InfiniteOpt._point_variable_dependenciesMethod
_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.

source
InfiniteOpt._derivative_dependenciesFunction
_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.

source
InfiniteOpt._derivative_dependenciesMethod
_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.

source
InfiniteOpt._measure_dependenciesFunction
_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.

source
InfiniteOpt._measure_dependenciesMethod
_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.

source
InfiniteOpt._generative_measuresFunction
_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.

source
InfiniteOpt._generative_measuresMethod
_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.

source
InfiniteOpt._constraint_dependenciesFunction
_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.

source
InfiniteOpt._constraint_dependenciesMethod
_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.

source
InfiniteOpt._derivative_constraint_dependenciesFunction
_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.

source
InfiniteOpt._derivative_constraint_dependenciesMethod
_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.

source
InfiniteOpt._parameter_numberFunction
_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.

source
InfiniteOpt._parameter_numberMethod
_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.

source
InfiniteOpt._object_numberFunction
_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.

source
InfiniteOpt._object_numberMethod
_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.

source