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; optimizations = true)

Construct a CompiledSystem from the given SystemF. If optimizations = true then optimize is called on F before compiling.

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; optimizations = true)

Construct an InterpretedSystem from the given SystemF. If optimizations = true then optimize is called on F before compiling.

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

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 AbstractSystemF 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) <: AbstractSystem

Given a $n × N$ system F with $n > N$ this constructs the system $\mathfrak{R}(F; k)(x) = [I A]⋅F(x)$ where $I$ is a $k × k$ identity matrix and $A$ is random complex $k × n$ matrix. See Chapter 13.5 in ^[SW05] for more details.

RandomizedSystem(F::Union{System,AbstractSystem}, A::Matrix{ComplexF64})

Explicitly provide the used randomization matrix A.