Avoid redundant ifs (using generated functions?)

[PerezHz]

Currently, there are some patterns in the code which go along the lines of

for T in (:Taylor1, :TaylorN)
    # NOTE: For $T = TaylorN, `mul!` *accumulates* the result of a * b in c[k]
    @eval @inline function mul!(c::$T{T}, a::$T{T}, b::$T{T}, k::Int) where {T<:Number}
        if $T == Taylor1
            @inbounds c[k] = a[0] * b[k]
            @inbounds for i = 1:k
                c[k] += a[i] * b[k-i]
            end
        else
            @inbounds mul!(c[k], a[0], b[k])
            @inbounds for i = 1:k
                mul!(c[k], a[i], b[k-i])
            end
        end
        return nothing
    end
# ...
end

(these lines can be be found around here:

TaylorSeries.jl/src/arithmetic.jl

Line 511 in 0585883

if $T == Taylor1

)

I gather such patterns avoid code repetitions, while generally the "cost" of running these ifs is quite low. Just for the sake of confirming this, I experimented a bit with generated functions, which allow to preserve the specialization for each type while avoiding code repetition, with the advantage of resolving them at compilation time, instead of being checked during run time once per method call. This can become important when handling mixtures of Taylor1{TaylorN{T}} in TaylorIntegration, where the number of coefficients can be quite large, and these if's can be checked many times during run time, when it's only necessary to check them at dispatch.

Gotten to this point, though, maybe an equally good solution would be to simply separate Taylor1 and TaylorN methods for patterns such as above? The latter can be more friendly to develop, and would avoid the use of generated functions, which looks maybe a bit overkill here?

So essentially what I'm proposing is to either remove the if $T == Taylor1 ... in the way they are now, or keep them by using generated functions, such that performance can improve a bit. Benchmarks I've run with TaylorIntegration on JT integrations show ~5% performance improvement. Not much indeed, but can be meaningful for longer runs.