Using BenchmarkTools (as suggested by Stefan) and Julia v0.7-alpha (as suggested by Chris), I see Julia being only slightly slower than R:
Edit: And the very latest Julia nightlies are even faster than R (see below)
julia> using BenchmarkTools
julia> @btime sum(skipmissing($y))
1.329 s (6 allocations: 96 bytes)
> system.time(sum(x, na.rm = T))
user system elapsed
0.940 0.000 0.941
That’s actually pretty good, since presumably R’s sum() is just calling a C function. Calling a single (C-implemented) function on a vector of data is pretty much the best possible case for R/NumPy/MATLAB/etc.
The important difference is that Julia’s sum(skipmissing(y)) is just calling Julia code all the way down. So if you want to implement your own kind of summation, you actually can and it will still be fast. Compare:
julia> function mysum(x)
result = zero(eltype(x))
for element in x
if !ismissing(element)
result += element
end
end
result
end
mysum (generic function with 1 method)
julia> @btime mysum($y)
809.128 ms (0 allocations: 0 bytes)
vs R:
> mysum <- function(x) {
+ result <- 0
+ for (element in x) {
+ if (!is.na(element)) {
+ result <- result + element
+ }
+ }
+ result
+ }
> system.time(mysum(x))
user system elapsed
107.094 0.000 107.093
The hand-written R sum is over 100 times slower than Julia.
So yes, if all you ever want to do is compute sums over vectors, then R is fine. But if you want to do something that doesn’t have a fast built-in C implementation, then you really want Julia.
By the way,
Are sentinelle values to represent missing values really out of the question?
No, certainly not. Julia v0.7 stores vectors of things like Union{Float64, Missing} efficiently by using a sentinel bit for each element. Or you can implement your own, which is what DataArrays does: https://github.com/JuliaStats/DataArrays.jl/blob/49004b5f82bb92ec7790805a0dda10b8c3aeb68b/src/dataarray.jl#L32-L70 and it will be fast, too.