TPS Methods

clearord(t1::TPS, order::Integer)

Returns a new TPS equal to t1 but with all monomial coefficients at the given order cleared (set equal to 0).

clearord!(t::TPS, order::Integer) -> t

Clears all monomial coefficients in t at order order.

clear!(t::TPS)

Clears all monomial coefficients in the TPS (sets to 0).

complex!(t::ComplexTPS64; tre=nothing, tim=nothing)

Sets t to so that real(t)=tre and imag(t)=tim in place.

compose!(m::Union{AbstractArray{T},T}, m2::Union{AbstractArray{T},T}, m1::AbstractArray{T}) where {T<:Union{TPS64,ComplexTPS64}} -> m

Composes the TPSs m2 ∘ m1, and stores the result in-place in m.

cutord(t1::TPS, order::Integer)

Cuts out the monomials in t1 at the given order and above. Or, if order is negative, will cut monomials with orders at and below abs(order).

Examples

julia> d = Descriptor(1,10);

julia> x = vars(d);

julia> cutord(sin(x[1]), 5)
TPS:
  Coefficient              Order     Exponent
   1.0000000000000000e+00    1        1
  -1.6666666666666666e-01    3        3


julia> cutord(sin(x[1]), -5)
TPS:
  Coefficient              Order     Exponent
  -1.9841269841269841e-04    7        7
   2.7557319223985893e-06    9        9

cutord!(t::TPS{T}, t1::TPS{T}, order::Integer) where {T<:TPS} -> t

Cuts out the monomials in t1 at the given order and above. Or, if order is negative, will cut monomials with orders at and below abs(order). t is filled in-place with the result. See the documentation for cutord for examples.

cycle!(t::TPS, i, n, m_, v_)

Given a starting index i (-1 if starting at 0), will optionally fill monomial m_ (if m != C_NULL, and m_ is a DenseVector{UInt8}) with the monomial at index i and optionally the value at v_ with the monomials coefficient (if v_ != C_NULL, and v_ is a Ref{<:Union{Float64,ComplexF64}}), and return the next NONZERO monomial index in the TPS. This is useful for iterating through each monomial in the TPSA.

Input

• t – TPS to scan
• i – Index to start from (-1 to start at 0)
• n – Length of monomial
• m_ – (Optional) Monomial to be filled if provided
• v_ – (Optional) Pointer to value of coefficient

Output

• i – Index of next nonzero monomial in the TPSA, or -1 if reached the end

deriv(t1::TPS, v::Union{TPSIndexType, Nothing}=nothing; param::Union{Integer,Nothing}=nothing, params::Union{SMIndexType, Nothing}=nothing)
∂(t1::TPS, v::Union{TPSIndexType, Nothing}=nothing; param::Union{Integer,Nothing}=nothing, params::Union{SMIndexType, Nothing}=nothing)

Differentiates t1 wrt the variable/parameter specified by the variable/parameter index, or alternatively any monomial specified by indexing-by-order OR indexing-by-sparse monomial.

Input

• v – An integer (for variable index), vector/tuple of orders for each variable (for indexing-by-order), or vector/tuple of pairs (sparse monomial)
• param – (Keyword argument, optional) An integer for the parameter index
• params – (Keyword argument, optional) Vector/tuple of pairs for sparse-monomial indexing

Examples: Variable/Parameter Index:

julia> d = Descriptor(1,5,1,5);

julia> x1 = vars(d)[1]; k1 = params(d)[1];

julia> deriv(x1*k1, 1)
TPS:
  Coefficient              Order     Exponent
   1.0000000000000000e+00    1        0    1


julia> deriv(x1*k1, param=1)
TPS:
  Coefficient              Order     Exponent
   1.0000000000000000e+00    1        1    0

Examples: Monomial Index-by-Order

julia> deriv(x1*k1, [1,0])
TPS:
  Coefficient              Order     Exponent
   1.0000000000000000e+00    1        0    1


julia> deriv(x1*k1, [0,1])
TPS:
  Coefficient              Order     Exponent
   1.0000000000000000e+00    1        1    0


julia> deriv(x1*k1, [1,1])
TPS:
  Coefficient              Order     Exponent
   1.0000000000000000e+00    0        0    0

Examples: Monomial Index-by-Sparse Monomial

julia> deriv(x1*k1, [1=>1])
TPS:
  Coefficient              Order     Exponent
   1.0000000000000000e+00    1        0    1


julia> deriv(x1*k1, params=[1=>1])
TPS:
  Coefficient              Order     Exponent
   1.0000000000000000e+00    1        1    0


julia> deriv(x1*k1, [1=>1], params=[1=>1])
TPS:
  Coefficient              Order     Exponent
   1.0000000000000000e+00    0        0    0

deriv!(t::TPS{T}, t1::TPS{T}, v::Union{TPSIndexType, Nothing}=nothing; param::Union{Integer,Nothing}=nothing, params::Union{SMIndexType, Nothing}=nothing) where {T} -> t 
∂!(t::TPS{T}, t1::TPS{T}, v::Union{TPSIndexType, Nothing}=nothing; param::Union{Integer,Nothing}=nothing, params::Union{SMIndexType, Nothing}=nothing)     where {T} -> t

Differentiates t1 wrt the variable/parameter specified by the variable/parameter index, or alternatively any monomial specified by indexing-by-order OR indexing-by-sparse monomial, and sets t equal to the result in-place. See the deriv documentation for examples.

Input

• v – An integer (for variable index), vector/tuple of orders for each variable (for indexing-by-order), or vector/tuple of pairs (sparse monomial)
• param – (Keyword argument, optional) An integer for the parameter index
• params – (Keyword argument, optional) Vector/tuple of pairs for sparse-monomial indexing

evaluate(m::Union{TPS,AbstractArray{<:TPS}}, x::AbstractArray{<:Number})

Evaluates the TPS function m at the result x.

evaluate!(y::Union{Ref{T},AbstractArray{T}}, m::Union{TPS{T},AbstractArray{TPS{T}}}, x::AbstractArray{T}) where {T<:Union{Float64,ComplexF64}} -> y

Evaluates the TPS function m at the point x and fills y with the result.

fgrad(F::AbstractArray{<:TPS}, h::TPS)

Calculates F⋅∇h.

fgrad!(g::T, F::AbstractArray{<:T}, h::T) where {T<:TPS} -> g

Calculates F⋅∇h and sets g equal to the result.

getord(t1::TPS, order::Integer)

Extracts one homogenous polynomial from t1 of the given order.

getord!(t::TPS{T}, t1::TPS{T}, order::Integer) where {T} -> t

Extracts one homogenous polynomial from t1 of the given order and fills t with the result in-place.

integ(t1::TPS, var::Integer=1)
∫(t1::TPS, var::Integer=1)

Integrates t1 wrt the variable var. Integration wrt parameters is not allowed, and integration wrt higher order monomials is not currently supported.

integ!(t::TPS{T}, t1::TPS{T}, var::Integer=1) where {T} -> t
∫!(t::TPS{T}, t1::TPS{T}, var::Integer=1)     where {T} -> t

Integrates t1 wrt the variable var and fills t with the result. Integration wrt parameters is not allowed, and integration wrt higher order monomials is not currently supported.

normTPS(t1::TPS)

Calculates the 1-norm of the TPS, which is the sum of the abs of all coefficients.

numcoefs(t::TPS)

Returns the maximum number of monomials (including the scalar part) in the TPS/ComplexTPS64 given its Descriptor.

numtype(::Union{Type{TPS{T}},TPS{T}}) where T

Returns the type of number that the TPS represents.

scalar(t::TPS)

Extracts the scalar part of the TPS. Equivalent to t[0] but this can be easily broadcasted.

setTPS!(t::TPS, t1::Number; change::Bool=false) -> t

General function for setting a TPS t equal to t1. If change is true, then t and t1 can have different Descriptors (with invalid monomials removed) so long as the number of variables + number of parameters are equal.

translate(m1::AbstractArray{<:TPS}, x::AbstractArray{<:Number})

Translates the expansion point of m1 by x.

translate!(m::Union{AbstractArray{T},T}, m1::Union{AbstractArray{T},T}, x::AbstractArray{U}) where {U<:Union{Float64,ComplexF64},T<:TPS{U}} -> m

Sets m to m1 with its expansion point translated by x.