Taylor Variables

Purpose

QSS methods rely heavily on root finding and derivative computation. The approximation through Taylor variables transforms any complicated equations to polynomials, which makes root finding cheaper. In addition, the use of Taylor variables provide easily the different derivatives for complex expressions. The implementation includes various constructors and methods to manipulate and evaluate the Taylor series.

In the quantized system solver, and similar to the Taylor struct from the package TaylorSeries.jl, the Taylor0 struct serves as a convenient representation of Taylor series approximations while avoiding memory allocation.

New functions are created to match each old function but with a different name and added caches in the parameters. These new functions are designed to optimize performance by avoiding memory allocation during their execution where arithmetic operations and mathematical functions leverage the existing cached data rather than creating new instances of taylor variables. In addition, the old Taylor is kept, with minimum functionalities, as a fallback in case there is an expression that does not use the available cache vector.

Arithmetic operations: The provided code introduces personalized arithmetic operations such as addsub, subsub, and mulT that are designed to operate directly on existing data structures, utilizing a caching mechanism to store intermediate results.

Mathematical functions: Similar to arithmetic operations, new mathematical functions are designed to leverage in-place operations. Functions like exp, log, sin, and cos, sqrt, power iterate over the input Taylor series and apply the corresponding operation without allocating additional arrays.

Transformation of expressions: The transformF function is designed to translate userdefined mathematical expressions into optimized forms that leverage the custom arithmetic and function implementations. By traversing the expression tree with the prewalk function, it identifies operations such as addition, subtraction, multiplication, division, and specific mathematical functions (like exponential and logarithmic functions). For each identified operation, the code modifies the expression to call specialized versions (e.g., subT, addT, mulT). Additionally, it tracks the number of caches needed for these operations.

Example:

function (+)(a::Taylor0, b::Taylor0)
    v = similar(a.coeffs)
    @__dot__ v = (+)(a.coeffs, b.coeffs)
    return Taylor0(v, a.order)
end

function addT(a::Taylor0, b::Taylor0, cache::Taylor0)
  @__dot__ cache.coeffs = (+)(a.coeffs, b.coeffs)
  return cache
end

The first function (+) from the TaylorSeries.jl creates a new Taylor variable every time, while the customized arithmetic operation addT uses an existing cache.

Taylor references

Taylor0 is defined for many functions. However, other functions can also be added.

QuantizedSystemSolver.Taylor0 — Type

Taylor0

defines a Taylor Variable. It has the following fields:

coeffs: An array of Float64 that holds the coefficients of the Taylor series
order: The order of the Taylor series