Systems

AbstractSystem

An abstract type representing a polynomial system $F(x, p)$ where $x$ are variables and $p$ are possible parameters.

CompiledSystem <: AbstractSystem

An AbstractSystem which automatically compiles a straight line program for the fast evaluation of a system F and its Jacobian. For large systems the compilation can take some time and require a large amount of memory. If this is a problem consider InterpretedSystem.

CompiledSystem(F::System)

Construct a CompiledSystem from the given System F.

InterpretedSystem <: AbstractSystem

An AbstractSystem which automatically generates a program for the fast evaluation of F and its Jacobian. The program is however, not compiled but rather interpreted. See also CompiledSystem.

InterpretedSystem(F::System)

Construct an InterpretedSystem from the given System F.

MixedSystem

A data structure which uses for evaluate! and evaluate_and_jacobian! a CompiledSystem and for taylor! an InterpretedSystem.

fixed(F::System; compile::Union{Bool,Symbol} = mixed)

Constructs either a CompiledSystem (if compile = :all), an InterpretedSystem (if compile = :none) or a MixedSystem (compile = :mixed).

set_default_compile(mode::Symbol)

Set the default value for the compile flag in solve and other functions. Possible values are :mixed (default), :all and :none.

AffineChartSystem(F::AbstractSystem, v::PVector{T,N})

Given a system $F(x): (ℙ^{m_1} × ⋯ × ℙ^{m_N}) → ℂⁿ$ this creates a new affine system $F′$ which operates on the affine chart defined by the vector $v ∈ ℙ^{m_1} × ⋯ × ℙ^{m_N}$ and the augmented conditions $vᵀx = 1$.

on_affine_chart(F::Union{System,AbstractSystem}, dimensions)

Construct an AffineChartSystem on a randomly generated chart v. Each entry is drawn idepdently from a univariate normal distribution.

CompositionSystem(G::AbstractSystem, F::AbstractSystem)

Construct the system $G(F(x;p);p)$. Note that the parameters are passed to $G$ and $F$ are identical.

compose(G::Union{AbstractSystem,System}, F::Union{AbstractSystem,System})

Construct the composition $G(F(x))$. You can also use the infix operator ∘ (written by \circ).

Example

julia> @var a b c x y z

julia> g = System([a * b * c]);

julia> f = System([x+y, y + z, x + z]);

julia> compose(g, f)
Composition G ∘ F:
F:
ModelKitSystem{(0xbb16b481c0808501, 1)}:
Compiled: System of length 3
 3 variables: x, y, z

 x + y
 y + z
 x + z

G:
ModelKitSystem{(0xf0a2384a42428501, 1)}:
Compiled: System of length 1
 3 variables: a, b, c

 a*b*c


julia> (g ∘ f)([x,y,z])
1-element Array{Expression,1}:
 (x + z)*(y + z)*(x + y)

FixedParameterSystem(F:AbstractSystem, parameters)

Construct a system from the given AbstractSystem F with the given parameters fixed.

fix_parameters(F::Union{System,AbstractSystem}, p; compile::Union{Bool,Symbol} = mixed)

Fix the parameters of the given system F. Returns a FixedParameterSystem.

RandomizedSystem(F::Union{System,AbstractSystem}, k::Integer;
        identity_block = true,
        compile = mixed)

Given a $n × N$ system Fthis constructs the system\mathfrak{R}(F; k)(x) = A⋅F(x)whereAis ak × Nmatrix. Ifidentity_block = truethen the firstkcolumns ofA` form an identity matrix. The other entries are random complex numbers. See Chapter 13.5 in ^[SW05] for more details.

RandomizedSystem(F::Union{System,AbstractSystem}, A::Matrix{ComplexF64};
    identity_block = true,
    compile = mixed)

Explicitly provide the used randomization matrix. If identity = true then A has to be k × (n - k) matrix. Otherwise A has to be a k × n matrix..

is_real(r::PathResult; tol::Float64 = 1e-6)

We consider a result as real if the infinity-norm of the imaginary part of the solution is at most tol.

is_real(certificate::AbstractSolutionCertificate)

Returns true if certificate certifies that the certified solution interval contains a true real zero of the system. If false is returned then this does not necessarily mean that the true solution is not real.