Engee 文档

Library

Module

TaylorSeries

A Julia package for Taylor expansions in one or more independent variables.

The basic constructors are Taylor1 and TaylorN; see also HomogeneousPolynomial.

Types

Taylor1{T<:Number} <: AbstractSeries{T}

DataType for polynomial expansions in one independent variable.

Fields:

  • coeffs :: Array{T,1} Expansion coefficients; the -th component is the coefficient of degree of the expansion.

  • order :: Int Maximum order (degree) of the polynomial.

Note that Taylor1 variables are callable. For more information, see evaluate.

HomogeneousPolynomial{T<:Number} <: AbstractSeries{T}

DataType for homogeneous polynomials in many (>1) independent variables.

Fields:

  • coeffs :: Array{T,1} Expansion coefficients of the homogeneous

polynomial; the -th component is related to a monomial, where the degrees of the independent variables are specified by coeff_table[order+1][i].

  • order :: Int order (degree) of the homogeneous polynomial.

Note that HomogeneousPolynomial variables are callable. For more information, see evaluate.

TaylorN{T<:Number} <: AbstractSeries{T}

DataType for polynomial expansions in many (>1) independent variables.

Fields:

  • coeffs :: Array{HomogeneousPolynomial{T},1} Vector containing the

HomogeneousPolynomial entries. The -th component corresponds to the homogeneous polynomial of degree .

  • order :: Int maximum order of the polynomial expansion.

Note that TaylorN variables are callable. For more information, see evaluate.

AbstractSeries{T<:Number} <: Number

Parameterized abstract type for Taylor1, HomogeneousPolynomial and TaylorN.

Functions and methods

Taylor1([T::Type=Float64], order::Int)

Shortcut to define the independent variable of a Taylor1{T} polynomial of given order. The default type for T is Float64.

julia> Taylor1(16)
 1.0 t + 𝒪(t¹⁷)

julia> Taylor1(Rational{Int}, 4)
 1//1 t + 𝒪(t⁵)
HomogeneousPolynomial([T::Type=Float64], nv::Int])

Shortcut to define the nv-th independent HomogeneousPolynomial{T}. The default type for T is Float64.

julia> HomogeneousPolynomial(1)
 1.0 x₁

julia> HomogeneousPolynomial(Rational{Int}, 2)
 1//1 x₂
TaylorN([T::Type=Float64], nv::Int; [order::Int=get_order()])

Shortcut to define the nv-th independent TaylorN{T} variable as a polynomial. The order is defined through the keyword parameter order, whose default corresponds to get_order(). The default of type for T is Float64.

julia> TaylorN(1)
 1.0 x₁ + 𝒪(‖x‖⁷)

julia> TaylorN(Rational{Int},2)
 1//1 x₂ + 𝒪(‖x‖⁷)
set_variables([T::Type], names::String; [order=get_order(), numvars=-1])

Return a TaylorN{T} vector with each entry representing an independent variable. names defines the output for each variable (separated by a space). The default type T is Float64, and the default for order is the one defined globally. Changing the order or numvars resets the hash_tables.

If numvars is not specified, it is inferred from names. If only one variable name is defined and numvars>1, it uses this name with subscripts for the different variables.

julia> set_variables(Int, "x y z", order=4)
3-element Array{TaylorSeries.TaylorN{Int},1}:
  1 x + 𝒪(‖x‖⁵)
  1 y + 𝒪(‖x‖⁵)
  1 z + 𝒪(‖x‖⁵)

julia> set_variables("α", numvars=2)
2-element Array{TaylorSeries.TaylorN{Float64},1}:
  1.0 α₁ + 𝒪(‖x‖⁵)
  1.0 α₂ + 𝒪(‖x‖⁵)

julia> set_variables("x", order=6, numvars=2)
2-element Array{TaylorSeries.TaylorN{Float64},1}:
  1.0 x₁ + 𝒪(‖x‖⁷)
  1.0 x₂ + 𝒪(‖x‖⁷)
get_variables(T::Type, [order::Int=get_order()])

Return a TaylorN{T} vector with each entry representing an independent variable. It takes the default params_TaylorN values if set_variables hasn’t been changed with the exception that order can be explicitly established by the user without changing internal values for num_vars or variable_names. Omitting T defaults to Float64.

show_params_TaylorN()

Display the current parameters for TaylorN and HomogeneousPolynomial types.

show_monomials(ord::Int) --> nothing

List the indices and corresponding of a HomogeneousPolynomial of degree ord.

getcoeff(a, n)

Return the coefficient of order n::Int of a a::Taylor1 polynomial.

getcoeff(a, v)

Return the coefficient of a::HomogeneousPolynomial, specified by v, which is a tuple (or vector) with the indices of the specific monomial.

getcoeff(a, v)

Return the coefficient of a::TaylorN, specified by v, which is a tuple (or vector) with the indices of the specific monomial.

evaluate(a, [dx])

Evaluate a Taylor1 polynomial using Horner’s rule (hand coded). If dx is omitted, its value is considered as zero. Note that the syntax a(dx) is equivalent to evaluate(a,dx), and a() is equivalent to evaluate(a).

evaluate(x, δt)

Evaluates each element of x::AbstractArray{Taylor1{T}}, representing the dependent variables of an ODE, at time δt. Note that the syntax x(δt) is equivalent to evaluate(x, δt), and x() is equivalent to evaluate(x).

evaluate(a, x)

Substitute x::Taylor1 as independent variable in a a::Taylor1 polynomial. Note that the syntax a(x) is equivalent to evaluate(a, x).

evaluate(a, [vals])

Evaluate a HomogeneousPolynomial polynomial at vals. If vals is omitted, it’s evaluated at zero. Note that the syntax a(vals) is equivalent to evaluate(a, vals); and a() is equivalent to evaluate(a).

evaluate(a, [vals]; sorting::Bool=true)

Evaluate the TaylorN polynomial a at vals. If vals is omitted, it’s evaluated at zero. The keyword parameter sorting can be used to avoid sorting (in increasing order by abs2) the terms that are added.

Note that the syntax a(vals) is equivalent to evaluate(a, vals); and a() is equivalent to evaluate(a). No extension exists that incorporates sorting.

evaluate!(x, δt, x0)

Evaluates each element of x::AbstractArray{Taylor1{T}}, representing the Taylor expansion for the dependent variables of an ODE at time δt. It updates the vector x0 with the computed values.

taylor_expand(f, x0; order)

Computes the Taylor expansion of the function f around the point x0.

If x0 is a scalar, a Taylor1 expansion will be returned. If x0 is a vector, a TaylorN expansion will be computed. If the dimension of x0 (length(x0)) is different from the variables set for TaylorN (get_numvars()), an AssertionError will be thrown.

update!(a, x0)

Takes a <: Union{Taylo1,TaylorN} and expands it around the coordinate x0.

differentiate(a)

Return the Taylor1 polynomial of the differential of a::Taylor1. The order of the result is a.order-1.

The function derivative is an exact synonym of differentiate.

differentiate(a, n)

Compute recursively the Taylor1 polynomial of the n-th derivative of a::Taylor1. The order of the result is a.order-n.

differentiate(n, a)

Return the value of the n-th differentiate of the polynomial a.

differentiate(a, r)

Partial differentiation of a::HomogeneousPolynomial series with respect to the r-th variable.

differentiate(a, r)

Partial differentiation of a::TaylorN series with respect to the r-th variable. The r-th variable may be also specified through its symbol.

differentiate(a::TaylorN{T}, ntup::NTuple{N,Int})

Return a TaylorN with the partial derivative of a defined by ntup::NTuple{N,Int}, where the first entry is the number of derivatives with respect to the first variable, the second is the number of derivatives with respect to the second, and so on.

differentiate(ntup::NTuple{N,Int}, a::TaylorN{T})

Returns the value of the coefficient of a specified by ntup::NTuple{N,Int}, multiplied by the corresponding factorials.

derivative

An exact synonym of differentiate.

integrate(a, [x])

Return the integral of a::Taylor1. The constant of integration (0-th order coefficient) is set to x, which is zero if omitted.

integrate(a, r)

Integrate the a::HomogeneousPolynomial with respect to the r-th variable. The returned HomogeneousPolynomial has no added constant of integration. If the order of a corresponds to get_order(), a zero HomogeneousPolynomial of 0-th order is returned.

integrate(a, r, [x0])

Integrate the a::TaylorN series with respect to the r-th variable, where x0 the integration constant and must be independent of the r-th variable; if x0 is omitted, it is taken as zero.

    gradient(f)
    ∇(f)

Compute the gradient of the polynomial f::TaylorN.

    jacobian(vf)
    jacobian(vf, [vals])

Compute the jacobian matrix of vf, a vector of TaylorN polynomials, evaluated at the vector vals. If vals is omitted, it is evaluated at zero.

    jacobian!(jac, vf)
    jacobian!(jac, vf, [vals])

Compute the jacobian matrix of vf, a vector of TaylorN polynomials evaluated at the vector vals, and write results to jac. If vals is omitted, it is evaluated at zero.

    hessian(f)
    hessian(f, [vals])

Return the hessian matrix (jacobian of the gradient) of f::TaylorN, evaluated at the vector vals. If vals is omitted, it is evaluated at zero.

    hessian!(hes, f)
    hessian!(hes, f, [vals])

Return the hessian matrix (jacobian of the gradient) of f::TaylorN, evaluated at the vector vals, and write results to hes. If vals is omitted, it is evaluated at zero.

constant_term(a)

Return the constant value (zero order coefficient) for Taylor1 and TaylorN. The fallback behavior is to return a itself if a::Number, or a[1] when a::Vector.

linear_polynomial(a)

Returns the linear part of a as a polynomial (Taylor1 or TaylorN), without the constant term. The fallback behavior is to return a itself.

nonlinear_polynomial(a)

Returns the nonlinear part of a. The fallback behavior is to return zero(a).

inverse(f)

Return the Taylor expansion of , of order N = f.order, for f::Taylor1 polynomial if the first coefficient of f is zero. Otherwise, a DomainError is thrown.

The algorithm implements Lagrange inversion at if :

abs(a)

For a Real type returns a if constant_term(a) > 0 and -a if constant_term(a) < 0 for a <:Union{Taylor1,TaylorN}. For a Complex type, such as Taylor1{ComplexF64}, returns sqrt(real(a)^2 + imag(a)^2).

Notice that typeof(abs(a)) <: AbstractSeries and that for a Complex argument a Real type is returned (e.g. typeof(abs(a::Taylor1{ComplexF64})) == Taylor1{Float64}).

norm(x::AbstractSeries, p::Real)

Returns the p-norm of an x::AbstractSeries, defined by

which returns a non-negative number.

isapprox(x::AbstractSeries, y::AbstractSeries; rtol::Real=sqrt(eps), atol::Real=0, nans::Bool=false)

Inexact equality comparison between polynomials: returns true if norm(x-y,1) <= atol + rtol*max(norm(x,1), norm(y,1)), where x and y are polynomials. For more details, see Base.isapprox.

isless(a::Taylor1{<:Real}, b::Real)
isless(a::TaylorN{<:Real}, b::Real)

Compute isless by comparing the constant_term(a) and b. If they are equal, returns a[nz] < 0, with nz the first non-zero coefficient after the constant term. This defines a total order.

For many variables, the ordering includes a lexicographical convention in order to be total. We have opted for the simplest one, where the larger variable appears before when the TaylorN variables are defined (e.g., through set_variables).

Refs:

  • M. Berz, AIP Conference Proceedings 177, 275 (1988); https://doi.org/10.1063/1.37800

  • M. Berz, "Automatic Differentiation as Nonarchimedean Analysis", Computer Arithmetic and Enclosure Methods, (1992), Elsevier, 439-450.

isless(a::Taylor1{<:Real}, b::Taylor1{<:Real})
isless(a::TaylorN{<:Real}, b::Taylor1{<:Real})

Return isless(a - b, zero(b)).

isfinite(x::AbstractSeries) -> Bool

Test whether the coefficients of the polynomial x are finite.

displayBigO(d::Bool) --> nothing

Set/unset displaying of the big 𝒪 notation in the output of Taylor1 and TaylorN polynomials. The initial value is true.

use_Base_show(d::Bool) --> nothing

Use Base.show_default method (default show method in Base), or a custom display. The initial value is false, so customized display is used.

set_taylor1_varname(var::String)

Change the displayed variable for Taylor1 objects.

Internals

ParamsTaylor1

DataType holding the current variable name for Taylor1.

Field:

  • var_name :: String Names of the variables

These parameters can be changed using set_taylor1_varname

ParamsTaylorN

DataType holding the current parameters for TaylorN and HomogeneousPolynomial.

Fields:

  • order :: Int Order (degree) of the polynomials

  • num_vars :: Int Number of variables

  • variable_names :: Vector{String} Names of the variables

  • variable_symbols :: Vector{Symbol} Symbols of the variables

These parameters can be changed using set_variables

_InternalMutFuncs

Contains parameters and expressions that allow a simple programmatic construction for calling the internal mutating functions.

generate_tables(num_vars, order)

Return the hash tables coeff_table, index_table, size_table and pos_table. Internally, these are treated as const.

Hash tables

coeff_table :: Array{Array{Array{Int,1},1},1}

The -th component contains a vector with the vectors of all the possible combinations of monomials of a HomogeneousPolynomial of order .

index_table :: Array{Array{Int,1},1}

The -th component contains a vector of (hashed) indices that represent the distinct monomials of a HomogeneousPolynomial of order (degree) .

size_table :: Array{Int,1}

The -th component contains the number of distinct monomials of the HomogeneousPolynomial of order , equivalent to length(coeff_table[i]).

pos_table :: Array{Dict{Int,Int},1}

The -th component maps the hash index to the (lexicographic) position of the corresponding monomial in coeffs_table.

generate_index_vectors(num_vars, degree)

Return a vector of index vectors with num_vars (number of variables) and degree.

in_base(order, v)

Convert vector v of non-negative integers to base oorder, where oorder is the next odd integer of order.

make_inverse_dict(v)

Return a Dict with the enumeration of v: the elements of v point to the corresponding index.

It is used to construct pos_table from index_table.

resize_coeffs1!{T<Number}(coeffs::Array{T,1}, order::Int)

If the length of coeffs is smaller than order+1, it resizes coeffs appropriately filling it with zeros.

resize_coeffsHP!{T<Number}(coeffs::Array{T,1}, order::Int)

If the length of coeffs is smaller than the number of coefficients correspondinf to order (given by size_table[order+1]), it resizes coeffs appropriately filling it with zeros.

numtype(a::AbstractSeries)

Returns the type of the elements of the coefficients of a.

mul!(c, a, b, k::Int) --> nothing

Update the k-th expansion coefficient c[k] of c = a * b, where all c, a, and b are either Taylor1 or TaylorN.

The coefficients are given by

mul!(c, a, b) --> nothing

Return c = a*b with no allocation; all arguments are HomogeneousPolynomial.

mul!(Y, A, B)

Multiply A*B and save the result in Y.

div!(c, a, b, k::Int)

Compute the k-th expansion coefficient c[k] of c = a / b, where all c, a and b are either Taylor1 or TaylorN.

The coefficients are given by

For Taylor1 polynomials, a similar formula is implemented which exploits k_0, the order of the first non-zero coefficient of a.

pow!(c, a, r::Real, k::Int)

Update the k-th expansion coefficient c[k] of c = a^r, for both c and a either Taylor1 or TaylorN.

The coefficients are given by

For Taylor1 polynomials, a similar formula is implemented which exploits k_0, the order of the first non-zero coefficient of a.

square(a::AbstractSeries) --> typeof(a)

Return a^2; see TaylorSeries.sqr!.

sqr!(c, a, k::Int) --> nothing

Update the k-th expansion coefficient c[k] of c = a^2, for both c and a either Taylor1 or TaylorN.

The coefficients are given by

sqr!(c, a)

Return c = a*a with no allocation; all parameters are HomogeneousPolynomial.

sqrt!(c, a, k::Int, k0::Int=0)

Compute the k-th expansion coefficient c[k] of c = sqrt(a) for bothc and a either Taylor1 or TaylorN.

The coefficients are given by

For Taylor1 polynomials, k0 is the order of the first non-zero coefficient, which must be even.

exp!(c, a, k) --> nothing

Update the k-th expansion coefficient c[k+1] of c = exp(a) for both c and a either Taylor1 or TaylorN.

The coefficients are given by

log!(c, a, k) --> nothing

Update the k-th expansion coefficient c[k+1] of c = log(a) for both c and a either Taylor1 or TaylorN.

The coefficients are given by

sincos!(s, c, a, k) --> nothing

Update the k-th expansion coefficients s[k+1] and c[k+1] of s = sin(a) and c = cos(a) simultaneously, for s, c and a either Taylor1 or TaylorN.

The coefficients are given by

tan!(c, a, p, k::Int) --> nothing

Update the k-th expansion coefficients c[k+1] of c = tan(a), for c and a either Taylor1 or TaylorN; p = c^2 and is passed as an argument for efficiency.

The coefficients are given by

asin!(c, a, r, k)

Update the k-th expansion coefficients c[k+1] of c = asin(a), for c and a either Taylor1 or TaylorN; r = sqrt(1-c^2) and is passed as an argument for efficiency.

acos!(c, a, r, k)

Update the k-th expansion coefficients c[k+1] of c = acos(a), for c and a either Taylor1 or TaylorN; r = sqrt(1-c^2) and is passed as an argument for efficiency.

atan!(c, a, r, k)

Update the k-th expansion coefficients c[k+1] of c = atan(a), for c and a either Taylor1 or TaylorN; r = 1+a^2 and is passed as an argument for efficiency.

sinhcosh!(s, c, a, k)

Update the k-th expansion coefficients s[k+1] and c[k+1] of s = sinh(a) and c = cosh(a) simultaneously, for s, c and a either Taylor1 or TaylorN.

The coefficients are given by

tanh!(c, a, p, k)

Update the k-th expansion coefficients c[k+1] of c = tanh(a), for c and a either Taylor1 or TaylorN; p = a^2 and is passed as an argument for efficiency.

asinh!(c, a, r, k)

Update the k-th expansion coefficients c[k+1] of c = asinh(a), for c and a either Taylor1 or TaylorN; r = sqrt(1-c^2) and is passed as an argument for efficiency.

acosh!(c, a, r, k)

Update the k-th expansion coefficients c[k+1] of c = acosh(a), for c and a either Taylor1 or TaylorN; r = sqrt(c^2-1) and is passed as an argument for efficiency.

atanh!(c, a, r, k)

Update the k-th expansion coefficients c[k+1] of c = atanh(a), for c and a either Taylor1 or TaylorN; r = 1-a^2 and is passed as an argument for efficiency.

differentiate!(res, a) --> nothing

In-place version of differentiate. Compute the Taylor1 polynomial of the differential of a::Taylor1 and return it as res (order of res remains unchanged).

differentiate!(p, a, k) --> nothing

Update in-place the k-th expansion coefficient p[k] of p = differentiate(a) for both p and a Taylor1.

The coefficients are given by

_internalmutfunc_call( fn :: _InternalMutFuncs )

Creates the appropriate call to the internal mutating function defined by the _InternalMutFuncs object. This is used to construct _dict_unary_calls and _dict_binary_calls. The call contains the prefix TaylorSeries..

_dict_binary_ops

Dict{Symbol, Array{Any,1}} with the information to construct the _InternalMutFuncs related to unary operations.

The keys correspond to the function symbols.

The arguments of the array are the function name (e.g. add!), a tuple with the function arguments, and an Expr with the calling pattern. The convention for the arguments of the functions and the calling pattern is to use :_res for the (mutated) result, :_arg1, for the required argument, possibly :_aux when there is an auxiliary expression needed, and :_k for the computed order of :_res. When an auxiliary expression is required, an Expr defining its calling pattern is added as the last entry of the vector.

_dict_binary_calls::Dict{Symbol, NTuple{2,Expr}}

Dictionary with the expressions that define the internal binary functions and the auxiliary functions, whenever they exist. The keys correspond to those functions, passed as symbols, with the defined internal mutating functions.

Evaluating the entries generates symbols that represent the actual calls to the internal mutating functions.

_dict_unary_calls::Dict{Symbol, NTuple{2,Expr}}

Dictionary with the expressions that define the internal unary functions and the auxiliary functions, whenever they exist. The keys correspond to those functions, passed as symbols, with the defined internal mutating functions.

Evaluating the entries generates expressions that represent the actual calls to the internal mutating functions.

_dict_binary_ops

Dict{Symbol, Array{Any,1}} with the information to construct the _InternalMutFuncs related to binary operations.

The keys correspond to the function symbols.

The arguments of the array are the function name (e.g. add!), a tuple with the function arguments, and an Expr with the calling pattern. The convention for the arguments of the functions and the calling pattern is to use :_res for the (mutated) result, :_arg1 and _arg2 for the required arguments, and :_k for the computed order of :_res.

@isonethread (expr)

Internal macro used to check the number of threads in use, to prevent a data race that modifies coeff_table when using differentiate or integrate; see https://github.com/JuliaDiff/TaylorSeries.jl/issues/318.

This macro is inspired by the macro @threaded; see https://github.com/trixi-framework/Trixi.jl/blob/main/src/auxiliary/auxiliary.jl; and https://github.com/trixi-framework/Trixi.jl/pull/426/files.

Index