0 "Argument n out of bounds."
out = Vector{T}(undef, N)
w = Vector{T}(undef, N)
c = 1-alpha
w_sum = 1.0
w[end] = 1.0
@inbounds for i in Iterators.take(eachindex(x), N-1)
w[end - i] = w[end - i + 1] * c # c^i - why is multiplication slower than exponentiation?
out[i] = dot(@view(w[end-i+1:end]), @view(x[1:i])) / w_sum
w_sum += w[end-i]
end
out[end] = dot(w, x) / w_sum
out[1:(n-1)] .= NaN
return out
end
```
---
### Author:  [@nsajko](https://discourse.julialang.org/u/nsajko)
#### Post date: [November 19, 2023, 1:26am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/2 "2023-11-19T01:26:15Z")
> [@AUK1939](#):
>
> ```julia
> w = Vector{T}(undef, N)
>
> w = [(1-alpha)^i for i in N-1:-1:0]
>
> ```
This might just be a typo, but note that the first line has no effect, except possibly hurting performance, as the following line overwrites `w` anyway.
EDIT: deleted lots of irrelevant content.
---
### Author:  [@Dan](https://discourse.julialang.org/u/Dan)
#### Post date: [November 19, 2023, 2:07am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/3 "2023-11-19T02:07:12Z")
Not sure I have the right formula, but it checked out in one test-case 😛 :
```julia
function ewma3(x::Vector{Float64}; n=10, alpha=2.0/(n+1))
N = length(x)
c = 1-alpha
ci = 1.0
r = 0.0
res = similar(x)
@inbounds for i in eachindex(res)
r = c*r + alpha*x[i]
ci *= c
res[i] = i < n ? NaN : r/(1-ci)
end
return res
end
```
It is also a few times faster.
---
### Author:  [@nsajko](https://discourse.julialang.org/u/nsajko)
#### Post date: [November 19, 2023, 2:17am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/4 "2023-11-19T02:17:56Z")
> [@Dan](#):
>
> `1-c`
Presumably this should just be `alpha`?
---
### Author:  [@Dan](https://discourse.julialang.org/u/Dan)
#### Post date: [November 19, 2023, 2:18am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/5 "2023-11-19T02:18:32Z")
`1-c` looks better (doesn’t change benchmark)
---
### Author:  [@nsajko](https://discourse.julialang.org/u/nsajko)
#### Post date: [November 19, 2023, 2:20am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/6 "2023-11-19T02:20:20Z")
Not sure, but an extra subtraction seems like it could decrease the accuracy a tiny bit?
---
### Author:  [@Dan](https://discourse.julialang.org/u/Dan)
#### Post date: [November 19, 2023, 2:21am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/7 "2023-11-19T02:21:26Z")
Maybe… I can change it. But what would really speed things up is somehow avoiding a division each iteration
---
### Author:  [@nsajko](https://discourse.julialang.org/u/nsajko)
#### Post date: [November 19, 2023, 2:30am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/8 "2023-11-19T02:30:50Z")
> [@Dan](#):
>
> `r = c*r + alpha*x[i]`
Maybe slightly faster: `r += alpha*(x[i] - r)`?
---
### Author:  [@Dan](https://discourse.julialang.org/u/Dan)
#### Post date: [November 19, 2023, 2:36am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/9 "2023-11-19T02:36:03Z")
> [@nsajko](#):
>
> r += alpha\*(x[i] - r)
Not faster, but deffos educational: it shows `r` performing a ‘gradient step’ towards `x[i]` with learning rate `alpha`.
---
### Author:  [@AUK1939](https://discourse.julialang.org/u/AUK1939)
#### Post date: [November 19, 2023, 3:01am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/11 "2023-11-19T03:01:22Z")
@Dan This seems to check out for me and it’s way faster than pandas (by at least 20 times on my machine). I’m trying to work out the Maths in the general case. Did you rearrange the formula somehow? If I read the code correctly you’re computing the following
$$\frac{\alpha (1-\alpha )^2 x\_1+\alpha (1-\alpha ) x\_2+\alpha x\_3}{1-(1-\alpha )^3}$$
What’s the logic behind this improvement?
---
### Author:  [@Dan](https://discourse.julialang.org/u/Dan)
#### Post date: [November 19, 2023, 3:08am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/12 "2023-11-19T03:08:37Z")
The logic goes back to the idea of Exponentially Weighted Moving Average. The benefit of exponential weights is that the sum of all previous weights in the current step, is the sum of weights in the previous step times a factor plus a correction. So by multiplying by this factor, both numerator and denominator of the moving average can be calculated simply. The denominator is a simple geometric series, for which there is a formula. The numerator correction depends on the new data element `x[i]`.
So no trick beyond the geometric series formula was used.
---
### Author:  [@AUK1939](https://discourse.julialang.org/u/AUK1939)
#### Post date: [November 19, 2023, 3:12am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/13 "2023-11-19T03:12:16Z")
@Dan ah I see the truncation is equivalent to the formula on the pandas page. Thanks
---
### Author:  [@nsajko](https://discourse.julialang.org/u/nsajko)
#### Post date: [November 19, 2023, 3:42am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/14 "2023-11-19T03:42:40Z")
Here’s a version that may be slightly faster, and I think more accurate:
```julia
function ewma_4(
x::AbstractArray{T,m},
n::Int = 10,
α::T = T(T(UInt8(2))/(n+1)),
c::T = true - α,
) where {T, m}
res = similar(x)
num = zero(T)::T
den = zero(T)::T
for i ∈ Base.OneTo(length(x))
j = i - 1
num = fma(num, c, x[begin + j])
den = fma(den, c, true)
res[begin + j] = num/den
end
res::AbstractArray{T,m}
end
```
---
### Author:  [@nsajko](https://discourse.julialang.org/u/nsajko)
#### Post date: [November 19, 2023, 3:54am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/15 "2023-11-19T03:54:38Z")
A slight modification allows using Symbolics for verifying that the formula checks out:
```julia
function ewma_4_sym(x::AbstractArray{T,m}, c::T) where {T, m}
res = zeros(T, size(x))
num = zero(T)::T
den = zero(T)::T
for i ∈ Base.OneTo(length(x))
j = i - 1
num = muladd(num, c, x[begin + j])
den = muladd(den, c, true)
res[begin + j] = num/den
end
res::AbstractArray{T,m}
end
```
```julia-repl
julia> include("/home/nsajko/EWMA/EWMA.jl");
julia> using Symbolics
julia> @variables x[1:6]
1-element Vector{Symbolics.Arr{Num, 1}}:
x[1:6]
julia> @variables c
1-element Vector{Num}:
c
julia> EWMA.ewma_4_sym(x, c)
6-element Vector{Num}:
x[1]
(x[2] + c*x[1]) / (true + c)
(x[3] + c*(x[2] + c*x[1])) / (true + (true + c)*c)
(x[4] + c*(x[3] + c*(x[2] + c*x[1]))) / (true + c*(true + (true + c)*c))
(x[5] + c*(x[4] + c*(x[3] + c*(x[2] + c*x[1])))) / (true + c*(true + c*(true + (true + c)*c)))
(x[6] + c*(x[5] + c*(x[4] + c*(x[3] + c*(x[2] + c*x[1]))))) / (true + c*(true + c*(true + c*(true + (true + c)*c))))
```
---
### Author:  [@Dan](https://discourse.julialang.org/u/Dan)
#### Post date: [November 19, 2023, 3:57am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/16 "2023-11-19T03:57:23Z")
Adding an `@inbounds` helps the benchmark. Also, limiting parameter to a Vector instead of `where {m}` seems acceptable in this case (unless a `dim` parameter is added).
---
### Author:  [@adienes](https://discourse.julialang.org/u/adienes)
#### Post date: [November 19, 2023, 4:00am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/17 "2023-11-19T04:00:37Z")
on my machine gets about another 2x as fast if you use `fma(num, c, x[i])` instead of `num*c + x[i]` and same for `den`
---
### Author:  [@nsajko](https://discourse.julialang.org/u/nsajko)
#### Post date: [November 19, 2023, 4:01am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/18 "2023-11-19T04:01:20Z")
> [@adienes](#):
>
> fma
Already made the edit a few minutes ago 😁
---
### Author:  [@lmiq](https://discourse.julialang.org/u/lmiq)
#### Post date: [November 19, 2023, 11:26am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/19 "2023-11-19T11:26:12Z")
> [@nsajko](#):
>
> `res::AbstractArray{T,m}`
What’s the purpose of this type conversion? Particularly to an abstract type?
---
### Author:  [@lmiq](https://discourse.julialang.org/u/lmiq)
#### Post date: [November 19, 2023, 11:37am UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/20 "2023-11-19T11:37:30Z")
Unfortunately I can’t test now. But how much faster is the fastest alternative relative to the simpler:
```julia
function ewma5(x::AbstractArray{T}, c::T) where {T}
res = zeros(T, size(x))
num = zero(T)
den = zero(T)
for i ∈ eachindex(x)
j = i - 1
num += c * x[begin + j]
den += c
res[begin + j] = num / den
end
return res
end
```
And to this one with `@turbo` (or `@inbounds @simd`) in the loop?
I’m asking because I feel that these excessive optimizations (although cool) scary new users and cause an impression that proper performance in Julia is only achieved with these tricks.
---
### Author:  [@AUK1939](https://discourse.julialang.org/u/AUK1939)
#### Post date: [November 19, 2023, 2:05pm UTC](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416/21 "2023-11-19T14:05:52Z")
amazing! started off at ~5ms with my crappy algo, and this is now runs under 5µs.
[Next page](https://discourse.julialang.org/t/make-ewma-as-fast-as-pandas/106416.md?page=2)