Библиотека

Модуль

# TaylorSeries.TaylorSeries — Module

TaylorSeries

Пакет Julia для разложений по Тейлору по одной или нескольким независимым переменным.

Основными конструкторами являются Taylor1 и TaylorN. См. также описание HomogeneousPolynomial.

Типы

# TaylorSeries.Taylor1 — Type

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

Тип данных для разложения многочлена по одной независимой переменной.

Поля:

coeffs :: Array{T,1} Коэффициенты разложения. -я компонента является коэффициентом степени разложения.
order :: Int Максимальный порядок (степень) многочлена.

Обратите внимание, что переменные Taylor1 можно вызывать. Дополнительные сведения см. в описании evaluate.

# TaylorSeries.HomogeneousPolynomial — Type

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

DataType для однородных многочленов по множеству (>1) независимых переменных.

Поля:

coeffs :: Array{T,1} Коэффициенты разложения однородного

многочлена. -я компонента относится к одночлену, где степени независимых переменных задаются coeff_table[order+1][i].

order :: Int Порядок (степень) однородного многочлена.

Обратите внимание, что переменные HomogeneousPolynomial можно вызывать. Дополнительные сведения см. в описании evaluate.

# TaylorSeries.TaylorN — Type

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

DataType для разложений многочленов по множеству (>1) независимых переменных.

Поля:

coeffs :: Array{HomogeneousPolynomial{T},1} Вектор, содержащий

записи HomogeneousPolynomial. -я компонента соответствует однородному многочлену степени .

order :: Int Максимальный порядок разложения многочлена.

Обратите внимание, что переменные TaylorN можно вызывать. Дополнительные сведения см. в описании evaluate.

# TaylorSeries.AbstractSeries — Type

AbstractSeries{T<:Number} <: Number

Параметризованный абстрактный тип для Taylor1, HomogeneousPolynomial и TaylorN.

Функции и методы

# TaylorSeries.Taylor1 — Method

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

Заполнитель для определения независимой переменной многочлена Taylor1{T} заданного порядка (order). Типом по умолчанию для T является Float64.

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

julia> Taylor1(Rational{Int}, 4)
 1//1 t + 𝒪(t⁵)

# TaylorSeries.HomogeneousPolynomial — Method

HomogeneousPolynomial([T::Type=Float64], nv::Int])

Заполнитель для определения nv-го независимого многочлена HomogeneousPolynomial{T}. Типом по умолчанию для T является Float64.

julia> HomogeneousPolynomial(1)
 1.0 x₁

julia> HomogeneousPolynomial(Rational{Int}, 2)
 1//1 x₂

# TaylorSeries.TaylorN — Method

TaylorN([T::Type=Float64], nv::Int; [order::Int=get_order()])

Заполнитель для определения nv-й независимой переменной TaylorN{T} в качестве многочлена. Порядок определяется с помощью параметра ключевого слова order, значением по умолчанию которого является get_order(). Типом по умолчанию для T является Float64.

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

julia> TaylorN(Rational{Int},2)
 1//1 x₂ + 𝒪(‖x‖⁷)

# TaylorSeries.set_variables — Function

set_variables([T::Type], names::String; [order=get_order(), numvars=-1])

Возвращает вектор TaylorN{T}, каждая запись которого представляет независимую переменную. names определяет вывод для каждой переменной (разделяемой пробелом). Типом по умолчанию T является Float64, в качестве значения по умолчанию для order используется то, которое определено глобально. Изменение order или numvars приводит к сбросу hash_tables.

Если значение numvars не указано, оно выводится из names. Если определено только одно имя переменной и numvars>1, используется это имя с нижними индексами для различных переменных.

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‖⁷)

# TaylorSeries.get_variables — Function

get_variables(T::Type, [order::Int=get_order()])

Возвращает вектор TaylorN{T}, каждая запись которого представляет независимую переменную. Принимает заданные по умолчанию значения params_TaylorN, если функция set_variables не была изменена, за исключением того, что порядок (order) может быть явно установлен пользователем без изменения внутренних значений для num_vars или variable_names. Если опустить T, по умолчанию используется Float64.

# TaylorSeries.show_params_TaylorN — Function

show_params_TaylorN()

Отображает текущие параметры для типов TaylorN и HomogeneousPolynomial.

# TaylorSeries.show_monomials — Function

show_monomials(ord::Int) --> nothing

Перечисляет индексы и соответствия HomogeneousPolynomial степени ord.

# TaylorSeries.getcoeff — Function

getcoeff(a, n)

Возвращает коэффициент порядка n::Int многочлена a::Taylor1.

getcoeff(a, v)

Возвращает коэффициент a::HomogeneousPolynomial, заданный с помощью v, который представляет собой кортеж (или вектор) с индексами конкретного одночлена.

getcoeff(a, v)

Возвращает коэффициент a::TaylorN, заданный с помощью v, который представляет собой кортеж (или вектор) с индексами конкретного одночлена.

# TaylorSeries.evaluate — Function

evaluate(a, [dx])

Вычисляет многочлен Taylor1, используя правило Горнера (с написанным вручную кодом). Если dx опущен, его значение считается нулевым. Обратите внимание, что синтаксис a(dx) эквивалентен evaluate(a,dx), а a() эквивалентен evaluate(a).

evaluate(x, δt)

Вычисляет каждый элемент x::AbstractArray{Taylor1{T}}, представляющий зависимую переменную уравнения ODE, в момент времени δt. Обратите внимание, что этот синтаксис x(δt) эквивалентен evaluate(x, δt), а x() эквивалентен evaluate(x).

evaluate(a::Taylor1, x::Taylor1)

Заменяет x::Taylor1 в качестве независимой переменной в многочлене a::Taylor1. Обратите внимание, что синтаксис a(x) эквивалентен evaluate(a, x).

evaluate(a, [vals])

Вычисляет HomogeneousPolynomial в vals. Если vals пропущен, он вычисляется как нулевой. Обратите внимание, что синтаксис a(vals) эквивалентен evaluate(a, vals), а a() эквивалентен evaluate(a).

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

Вычисляет многочлен TaylorN a в vals. Если vals пропущен, он вычисляется как нулевой. С помощью параметра ключевого слова sorting можно исключить сортировку (в порядке возрастания по abs2) добавляемых членов.

Обратите внимание, что синтаксис a(vals) эквивалентен evaluate(a, vals), а a() эквивалентен evaluate(a). Использование a(b::Bool, x) соответствует evaluate(a, x, sorting=b).

# TaylorSeries.evaluate! — Function

evaluate!(x, δt, x0)

Вычисляет каждый элемент x::AbstractArray{Taylor1{T}}, представляющий разложение по Тейлору для зависимых переменных уравнения ODE, в момент времени δt. Обновляет вектор x0 в соответствии с вычисленными значениями.

# TaylorSeries.taylor_expand — Function

taylor_expand(f, x0; order)

Вычисляет разложение по Тейлору функции f в окрестности точки x0.

Если x0 является скаляром, будет возвращено разложение Taylor1. Если x0 является вектором, будет вычислено разложение TaylorN. Если размерность x0 (length(x0)) отличается от переменных, заданных для TaylorN (get_numvars()), возникнет ошибка AssertionError.

# TaylorSeries.update! — Function

update!(a, x0)

Принимает a <: Union{Taylo1,TaylorN} и выполняет его разложение в окрестности координаты x0.

# TaylorSeries.differentiate — Function

differentiate(a)

Возвращает многочлен Taylor1 дифференциала a::Taylor1. Результат имеет порядок a.order-1.

Функция derivative является точным синонимом differentiate.

differentiate(a, n)

Рекурсивно вычисляет многочлен Taylor1 n-й производной от a::Taylor1. Результат имеет порядок a.order-n.

differentiate(n, a)

Возвращает значение n-го дифференциала многочлена a.

differentiate(a, r)

Частный дифференциал ряда a::HomogeneousPolynomial по r-й переменной.

differentiate(a, r)

Частный дифференциал ряда a::TaylorN по r-й переменной. r-ю переменную можно также указать с помощью ее символа.

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

Возвращает TaylorN с частной производной по a, определенной с помощью ntup::NTuple{N,Int}, где первая запись — это количество производных по первой переменной, вторая — количество производных по второй и так далее.

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

Возвращает коэффициент a, заданный с помощью ntup::NTuple{N,Int}, умноженный на соответствующие факториалы.

# TaylorSeries.derivative — Function

derivative

Точный синоним differentiate.

# TaylorSeries.integrate — Function

integrate(a, [x])

Возвращает интеграл a::Taylor1. Константа интегрирования (коэффициент 0-го порядка) задана равной x. Если она не указана, она принимается как равная нулю. Обратите внимание, что результат имеет порядок a.order+1.

integrate(a, r)

Интегрирует a::HomogeneousPolynomial по r-й переменной. Возвращаемый HomogeneousPolynomial не имеет добавленной константы интегрирования. Если порядок a соответствует get_order(), возвращается нулевой HomogeneousPolynomial 0-го порядка.

integrate(a, r, [x0])

Интегрирует ряд a::TaylorN по r-й переменной, где x0 является константой интегрирования, которая не должна зависеть от r-й переменной. Если константа x0 не указана, она принимается как равная нулю.

# TaylorSeries.gradient — Function

    gradient(f)
    ∇(f)

Compute the gradient of the polynomial f::TaylorN.

# TaylorSeries.jacobian — Function

    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.

# TaylorSeries.jacobian! — Function

    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.

# TaylorSeries.hessian — Function

    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.

# TaylorSeries.hessian! — Function

    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.

# TaylorSeries.constant_term — Function

constant_term(a)

Возвращает значение константы (коэффициент нулевого порядка) для Taylor1 и TaylorN. В качестве запасного варианта возвращается само a, если a::Number, или a[1], когда a::Vector.

# TaylorSeries.linear_polynomial — Function

linear_polynomial(a)

Возвращает линейную часть a в виде многочлена (Taylor1 или TaylorN) без постоянного члена. В качестве запасного варианта возвращается само a.

# TaylorSeries.nonlinear_polynomial — Function

nonlinear_polynomial(a)

Возвращает нелинейную часть a. В качестве запасного варианта возвращается zero(a).

# TaylorSeries.inverse — Function

inverse(f)

Возвращает разложение по Тейлору порядка N = f.order для многочлена f::Taylor1, если первый коэффициент f равен нулю. В противном случае возникает ошибка DomainError.

Алгоритм реализует лангражеву инверсию при , если :

# Base.abs — Function

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

# LinearAlgebra.norm — Function

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

Возвращает p-норму x::AbstractSeries, определяемую следующим образом:

что возвращает неотрицательное число.

# Base.isapprox — Function

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

Неточное сравнение на равенство многочленов: возвращается true, если norm(x-y,1) <= atol + rtol*max(norm(x,1), norm(y,1)), где x и y являются многочленами. Дополнительные сведения см. в описании Base.isapprox.

# Base.isless — Function

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

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

# Base.isfinite — Function

isfinite(x::AbstractSeries) -> Bool

Проверяет, являются ли коэффициенты многочлена x конечными.

# TaylorSeries.displayBigO — Function

displayBigO(d::Bool) --> nothing

Включает или отключает отображение нотации big 𝒪 в выводе многочленов Taylor1 и TaylorN. Начальное значение — true.

# TaylorSeries.use_show_default — Function

use_Base_show(d::Bool) --> nothing

Использует метод Base.show_default (метод по умолчанию — show в Base) или пользовательское отображение. Начальное значение — false, поэтому используется пользовательское отображение.

# TaylorSeries.set_taylor1_varname — Function

set_taylor1_varname(var::String)

Изменяет отображаемую переменную для объектов Taylor1.

Внутренние компоненты

# TaylorSeries.ParamsTaylor1 — Type

ParamsTaylor1

DataType, содержащий имя текущей переменной для Taylor1.

Поле:

var_name :: String Имена переменных

Эти параметры можно изменить с помощью функции set_taylor1_varname.

# TaylorSeries.ParamsTaylorN — Type

ParamsTaylorN

DataType, содержащего имя текущей переменной для TaylorN и HomogeneousPolynomial.

Поля:

order :: Int Порядок (степень) многочленов
num_vars :: Int Количество переменных
variable_names :: Vector{String} Имена переменных
variable_symbols :: Vector{Symbol} Символы переменных

Эти параметры можно изменить с помощью функции set_variables.

# TaylorSeries._InternalMutFuncs — _Type

_InternalMutFuncs

Содержит параметры и выражения, которые позволяют создать простую программную конструкцию для вызова внутренних изменяемых функций.

# TaylorSeries.generate_tables — Function

generate_tables(num_vars, order)

Возвращает хэш-таблицы coeff_table, index_table, size_table и pos_table. Внутренне они рассматриваются как const.

Хэш-таблицы

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

-я компонента содержит вектор с векторами всех возможных сочетаний одночленов HomogeneousPolynomial порядка .

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

-я компонента содержит вектор (хэшированных) индексов, которые представляют отдельные одночлены HomogeneousPolynomial порядка (степени) .

size_table :: Array{Int,1}

-я компонента содержит количество отдельных одночленов HomogeneousPolynomial порядка , что эквивалентно length(coeff_table[i]).

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

-я компонента сопоставляет хэш-индекс с (лексикографической) позицией соответствующего одночлена в coeffs_table.

# TaylorSeries.generate_index_vectors — Function

generate_index_vectors(num_vars, degree)

Возвращает вектор векторов индексов с num_vars (количество переменных) и степенью.

# TaylorSeries.in_base — Function

in_base(order, v)

Преобразует вектор v неотрицательных целых чисел в основание oorder, где oorder является следующим нечетным целым числом для order.

# TaylorSeries.make_inverse_dict — Function

make_inverse_dict(v)

Возвращает словарь с перечислением v: элементы v указывают на соответствующий индекс.

Это используется для создания pos_table из index_table.

# TaylorSeries.resize_coeffs1! — Function

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

Если длина coeffs меньше, чем order+1, функция изменяет размер coeffs, заполняя их нулями.

# TaylorSeries.resize_coeffsHP! — Function

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

Если длина coeffs меньше количества коэффициентов, соответствующих order (заданному size_table[order+1]), функция изменяет размер coeffs, заполняя их нулями.

# TaylorSeries.numtype — Function

numtype(a::AbstractSeries)

Возвращает тип элементов коэффициентов a.

# LinearAlgebra.mul! — Function

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

Обновляет k-й коэффициент разложения c[k] для c = a * b, где все c, a и b имеют значение либо Taylor1, либо TaylorN. Обратите внимание, что для TaylorN результат a * b накапливается в c[k].

Коэффициенты задаются следующим образом.

# LinearAlgebra.mul! — Method

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

Накапливает в c результат a*b с минимальным выделением. Аргументы c, a и b имеют значение HomogeneousPolynomial.

# LinearAlgebra.mul! — Method

mul!(Y, A, B)

Умножает A на B и сохраняет результат в Y.

# TaylorSeries.div! — Function

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

Вычисляет k-th коэффициент разложения c[k] для c = a / b, где все c, a и b имеют значение либо Taylor1, либо TaylorN.

Коэффициенты задаются следующим образом.

Для многочленов Taylor1 применяется аналогичная формула, использующая k_0 — порядок первого ненулевого коэффициента a.

# TaylorSeries.pow! — Function

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

Обновляет k-й коэффициент разложения c[k] для c = a^r, для обоих c и a либо Taylor1, либо TaylorN.

Коэффициенты задаются следующим образом.

# TaylorSeries.square — Function

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

Возвращает a^2. См. описание TaylorSeries.sqr!.

# TaylorSeries.sqr! — Function

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

Обновляет k-th коэффициент разложения c[k] для c = a^2, для обоих c и a либо Taylor1, либо TaylorN.

Коэффициенты задаются следующим образом.

# TaylorSeries.sqrt! — Function

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

Вычисляет k-th коэффициент разложения c[k] для c = sqrt(a), для обоих c и a либо Taylor1, либо TaylorN.

Коэффициенты задаются следующим образом.

Для многочленов Taylor1 k0 является порядком первого ненулевого коэффициента, который должен быть четным.

# TaylorSeries.exp! — Function

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

Обновляет k-th коэффициент разложения c[k+1] для c = exp(a), для обоих c и a либо Taylor1, либо TaylorN.

Коэффициенты задаются следующим образом.

# TaylorSeries.log! — Function

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

Обновляет k-th коэффициент разложения c[k+1] для c = log(a), для обоих c и a либо Taylor1, либо TaylorN.

Коэффициенты задаются следующим образом.

# TaylorSeries.sincos! — Function

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

Обновляет k-th коэффициенты разложения s[k+1] и c[k+1] для s = sin(a) и c = cos(a) одновременно для s, c и a либо Taylor1, либо TaylorN.

Коэффициенты задаются следующим образом.

# TaylorSeries.tan! — Function

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

Обновляет k-th коэффициенты разложения c[k+1] для c = tan(a), для c и a либо Taylor1, либо TaylorN; p = c^2 и передается в качестве аргумента для повышения эффективности.

Коэффициенты задаются следующим образом.

# TaylorSeries.asin! — Function

asin!(c, a, r, k)

Обновляет k-th коэффициенты разложения c[k+1] для c = asin(a), для c и a либо Taylor1, либо TaylorN; r = sqrt(1-c^2) и передается в качестве аргумента для повышения эффективности.

# TaylorSeries.acos! — Function

acos!(c, a, r, k)

Обновляет k-th коэффициенты разложения c[k+1] для c = acos(a), для c и a либо Taylor1, либо TaylorN; r = sqrt(1-c^2) и передается в качестве аргумента для повышения эффективности.

# TaylorSeries.atan! — Function

atan!(c, a, r, k)

Обновляет k-th коэффициенты разложения c[k+1] для c = atan(a), для c и a либо Taylor1, либо TaylorN; r = 1+a^2 и передается в качестве аргумента для повышения эффективности.

# TaylorSeries.sinhcosh! — Function

sinhcosh!(s, c, a, k)

Обновляет k-th коэффициенты разложения s[k+1] и c[k+1] для s = sinh(a) и c = cosh(a) одновременно для s, c и a либо Taylor1, либо TaylorN.

Коэффициенты задаются следующим образом.

# TaylorSeries.tanh! — Function

tanh!(c, a, p, k)

Обновляет k-th коэффициенты разложения c[k+1] для c = tanh(a), для c и a либо Taylor1, либо TaylorN; p = a^2 и передается в качестве аргумента для повышения эффективности.

# TaylorSeries.asinh! — Function

asinh!(c, a, r, k)

Обновляет k-th коэффициенты разложения c[k+1] для c = asinh(a), для c и a либо Taylor1, либо TaylorN; r = sqrt(1-c^2) и передается в качестве аргумента для повышения эффективности.

# TaylorSeries.acosh! — Function

acosh!(c, a, r, k)

Обновляет k-th коэффициенты разложения c[k+1] для c = acosh(a), для c и a либо Taylor1, либо TaylorN; r = sqrt(c^2-1) и передается в качестве аргумента для повышения эффективности.

# TaylorSeries.atanh! — Function

atanh!(c, a, r, k)

Обновляет k-th коэффициенты разложения c[k+1] для c = atanh(a), для c и a либо Taylor1, либо TaylorN; r = 1-a^2 и передается в качестве аргумента для повышения эффективности.

# TaylorSeries.differentiate! — Function

differentiate!(res, a) --> nothing

Версия differentiate, выполняемая на месте. Вычисляет многочлен Taylor1 дифференциала a::Taylor1 и возвращает его как res (порядок res остается неизменным).

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

Обновляет на месте k-th коэффициент разложения p[k] для p = differentiate(a), для обоих p и a Taylor1.

Коэффициенты задаются следующим образом.

# TaylorSeries._internalmutfunc_call — _Function

_internalmutfunc_call( fn :: _InternalMutFuncs )

Создает соответствующий вызов внутренней изменяемой функции, определяемой объектом _InternalMutFuncs. Этот способ используется для создания _dict_unary_calls и _dict_binary_calls. Вызов содержит префикс TaylorSeries..

# TaylorSeries._dict_unary_ops — _Constant

_dict_binary_ops

Dict{Symbol, Array{Any,1}} с информацией для построения функций _InternalMutFuncs, связанных с унарными операциями.

Ключи соответствуют символам функций.

Аргументами массива являются имя функции (например, add!), кортеж с аргументами функции и Expr с шаблоном вызова. Для аргументов функций и шаблона вызова принято использовать :_res для (измененного) результата, :_arg1 для необходимого аргумента, возможно :_aux, если необходимо вспомогательное выражение, и :_k для вычисленного порядка :_res. Когда требуется вспомогательное выражение, Expr, определяющий его шаблон вызова, добавляется в качестве последнего элемента вектора.

# TaylorSeries._dict_binary_calls — _Constant

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

Словарь с выражениями, определяющими внутренние бинарные функции и вспомогательные функции, если они существуют. Ключи соответствуют тем функциям, которые передаются как символы, с определенными внутренними изменяемыми функциями.

При оценке записей генерируются символы, которые представляют фактические вызовы внутренних изменяемых функций.

# TaylorSeries._dict_unary_calls — _Constant

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

Словарь с выражениями, определяющими внутренние унарные функции и вспомогательные функции, если они существуют. Ключи соответствуют тем функциям, которые передаются как символы, с определенными внутренними изменяемыми функциями.

При оценке записей генерируются выражения, которые представляют фактические вызовы внутренних изменяемых функций.

# TaylorSeries._dict_binary_ops — _Constant

_dict_binary_ops

Dict{Symbol, Array{Any,1}} с информацией для построения функций _InternalMutFuncs, связанных с бинарными операциями.

Ключи соответствуют символам функций.

# TaylorSeries.@isonethread — Macro

@isonethread (expr)

Для проверки количества используемых потоков применяется внутренний макрос, чтобы предотвратить гонку данных. Он изменяет coeff_table при использовании differentiate или integrate. См. страницу https://github.com/JuliaDiff/TaylorSeries.jl/issues/318.

Этот макрос создан на основе макроса @threaded. См. страницы по адресу: https://github.com/trixi-framework/Trixi.jl/blob/main/src/auxiliary/auxiliary.jl и https://github.com/trixi-framework/Trixi.jl/pull/426/files.

Указатель

TaylorSeries.AbstractSeries
TaylorSeries.HomogeneousPolynomial
TaylorSeries.HomogeneousPolynomial
TaylorSeries.ParamsTaylor1
TaylorSeries.ParamsTaylorN
TaylorSeries.Taylor1
TaylorSeries.Taylor1
TaylorSeries.TaylorN
TaylorSeries.TaylorN
TaylorSeries._InternalMutFuncs
Base.abs
Base.isapprox
Base.isfinite
Base.isless
LinearAlgebra.mul!
LinearAlgebra.mul!
LinearAlgebra.mul!
LinearAlgebra.norm
TaylorSeries._internalmutfunc_call
TaylorSeries.acos!
TaylorSeries.acosh!
TaylorSeries.asin!
TaylorSeries.asinh!
TaylorSeries.atan!
TaylorSeries.atanh!
TaylorSeries.constant_term
TaylorSeries.derivative
TaylorSeries.differentiate
TaylorSeries.differentiate!
TaylorSeries.displayBigO
TaylorSeries.div!
TaylorSeries.evaluate
TaylorSeries.evaluate!
TaylorSeries.exp!
TaylorSeries.generate_index_vectors
TaylorSeries.generate_tables
TaylorSeries.get_variables
TaylorSeries.getcoeff
TaylorSeries.gradient
TaylorSeries.hessian
TaylorSeries.hessian!
TaylorSeries.in_base
TaylorSeries.integrate
TaylorSeries.inverse
TaylorSeries.jacobian
TaylorSeries.jacobian!
TaylorSeries.linear_polynomial
TaylorSeries.log!
TaylorSeries.make_inverse_dict
TaylorSeries.nonlinear_polynomial
TaylorSeries.numtype
TaylorSeries.pow!
TaylorSeries.resize_coeffs1!
TaylorSeries.resize_coeffsHP!
TaylorSeries.set_taylor1_varname
TaylorSeries.set_variables
TaylorSeries.show_monomials
TaylorSeries.show_params_TaylorN
TaylorSeries.sincos!
TaylorSeries.sinhcosh!
TaylorSeries.sqr!
TaylorSeries.sqrt!
TaylorSeries.square
TaylorSeries.tan!
TaylorSeries.tanh!
TaylorSeries.taylor_expand
TaylorSeries.update!
TaylorSeries.use_show_default