Edit on GitHub

Relaxation of Implicit Functions

High-level functions

McCormick.implicit_relax_h! — Function
implicit_relax_h!(d)
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).

DataStructures

McCormick.AbstractContractorMC — Type
abstract type AbstractContractorMC

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

McCormick.NewtonGS — Type
struct NewtonGS <: McCormick.AbstractContractorMC

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

McCormick.KrawczykCW — Type
struct KrawczykCW <: McCormick.AbstractContractorMC

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

McCormick.AbstractPreconditionerMC — Type
abstract type AbstractPreconditionerMC

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

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

A dense LU preconditioner for implicit McCormick relaxation.

McCormick.AbstractMCCallback — Type
abstract type AbstractMCCallback

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

McCormick.MCCallback — Type
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.

Subroutines

McCormick.preconditioner_storage — Function
preconditioner_storage(x, t)

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

McCormick.affine_exp! — Function
affine_exp!(x, p, d)

Computates the affine relaxations of the state variable.

McCormick.correct_exp! — Function

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

McCormick.contract! — Function

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

McCormick.final_cut — Function
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.

McCormick.gen_expansion_params! — Function
gen_expansion_params!(d)
gen_expansion_params!(d, interval_bnds)

Constructs parameters need to compute relaxations of h.