Relaxation of Implicit Functions

High-level functions

implicit_relax_h!(d, interval_bnds)

Compute relaxations of x(p) defined by h(x,p) = 0 where h is specifed as h(out, x, p).


abstract type AbstractContractorMC

An abstract type for each manner of contractor using in the implicit function relaxation algorithms.

struct NewtonGS <: McCormick.AbstractContractorMC

The Gauss-Seidel implementation of the Newton contractor used in the implicit relaxation scheme.

struct KrawczykCW <: McCormick.AbstractContractorMC

The componentwise implementation of the Krawczyk contractor used in the implicit relaxation scheme.

abstract type AbstractPreconditionerMC

An abstract type for each manner of preconditioner used in the implicit function relaxation algorithms.

struct DenseMidInv{S<:VecOrMat{Float64}} <: McCormick.AbstractPreconditionerMC

A dense LU preconditioner for implicit McCormick relaxation.

abstract type AbstractMCCallback

An abstract type for each manner of callback functions used in the implicit function relaxation algorithms.

mutable struct MCCallback{FH, FJ, C<:McCormick.AbstractContractorMC, PRE<:McCormick.AbstractPreconditionerMC, N, T<:RelaxTag, AMAT<:(AbstractMatrix{T} where T)} <: AbstractMCCallback

A structure used to compute implicit relaxations.

  • h!::Any

    Function h(x,p) = 0 defined in place by h!(out,x,p)

  • hj!::Any

    Jacobian of h(x,p) w.r.t x

  • H::Array{MC{N, T}, 1} where {N, T<:RelaxTag}

    Intermediate inplace storage for output of h!

  • J::AbstractMatrix{T} where T

    Intermediate inplace storage for output of hj!

  • J0::Vector{AMAT} where AMAT<:(AbstractMatrix{T} where T)

  • xz0::Vector{AMAT} where AMAT<:(AbstractMatrix{T} where T)

  • xmid::Vector{Float64}

  • X::Vector{Interval{Float64}}

    State space x interval bounds

  • P::Vector{Interval{Float64}}

    Decision space p interval bounds

  • nx::Int64

    State space dimension

  • np::Int64

    Decision space dimension

  • λ::Float64

    Convex combination parameter

  • eps::Float64

    Tolerance for interval equality

  • kmax::Int64

    Number of contractor steps to take

  • pref_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}

    Reference decision point at which affine relaxations are calculated (and used in subsequent calculations).

  • p_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}

    Decision point at which relaxation is evaluated.

  • p_temp_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}

    Vector used to temporarily store p in genexpansionparams! routine.

  • x0_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}

  • x_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}

  • xa_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}

  • xA_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}

  • aff_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}

  • z_mc::Array{MC{N, T}, 1} where {N, T<:RelaxTag}

  • contractor::McCormick.AbstractContractorMC

    Type of contractor used in implicit relaxation routine.

  • preconditioner::McCormick.AbstractPreconditionerMC

    Preconditioner used in the implicit relaxation routine.

  • apply_precond::Bool

    Boolean indicating that the preconditioner should be applied

  • param::Array{Array{MC{N, T}, 1}, 1} where {N, T<:RelaxTag}

    Vector of relaxations of x at each iteration used to generated affine relaxations used in intermediate calculation.

  • use_apriori::Bool

    Indicates that subgradient-based apriori relaxations of multiplication should be used.


preconditioner_storage(x, t)

Creates storage corresponding to x::AbstractPreconditionerMC and t::T where T<:RelaxTag.

affine_exp!(x, p, d)

Computates the affine relaxations of the state variable.


Corrects the relaxation of the state variable x_mc if the affine relaxation,


Performs a single step of the parametric method associated with t assumes that the inputs have been preconditioned.

final_cut(x, y)

An operator that cuts the x object using the y bounds in a differentiable or nonsmooth fashion to achieve a composite relaxation within y.

gen_expansion_params!(d, interval_bnds)

Constructs parameters need to compute relaxations of h.