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

source

Data Structures

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

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

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

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

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

A dense LU preconditioner for implicit McCormick relaxation.

source
McCormick.AbstractMCCallback — Type
abstract type AbstractMCCallback

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

source
McCormick.MCCallback — Type
mutable struct MCCallback{FH, FJ, C<:McCormick.AbstractContractorMC, PRE<:McCormick.AbstractPreconditionerMC, N, T<:RelaxTag, AMAT<:(AbstractMatrix)} <: 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: Intermediate inplace storage for output of hj!

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

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

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

source

Subroutines

McCormick.contract! — Function

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

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

source