I’m confused by the difference when ^ is used with a literal vs a variable:
julia> p = -13;
julia> 3 ^ p
ERROR: DomainError with -13:
Cannot raise an integer x to a negative power -13.
Make x a float by adding a zero decimal (e.g., 2.0^-13 instead of 2^-13), or write 1/x^13, float(x)^-13, or (x//1)^-13
Stacktrace:
[1] throw_domerr_powbysq(::Int64, ::Int64) at ./intfuncs.jl:176
[2] power_by_squaring(::Int64, ::Int64) at ./intfuncs.jl:196
...
julia> 3 ^ -13
6.272254743863065e-7
julia> @code_llvm 3 ^ p
; Function ^
; Location: intfuncs.jl:220
define i64 @"julia_^_38072"(i64, i64) {
top:
%2 = call i64 @julia_power_by_squaring_24844(i64 %0, i64 %1)
ret i64 %2
}
julia> @code_llvm 3 ^ -13
; Function ^
; Location: intfuncs.jl:220
define i64 @"julia_^_38072"(i64, i64) {
top:
%2 = call i64 @julia_power_by_squaring_24844(i64 %0, i64 %1)
ret i64 %2
}
It’s surprising to me that although the code should do the same, something magically changes behaviour.
That’s a good question. I’m not sure that it is, but it definitely should be. If you grep Julia’s doc directory for literal_pow and don’t for anything, that means that it’s not. If so, please do file a doc issue. I would do it but I’m on a phone and won’t have a chance for a while.
This was a controversial change and there are still many people who are not entirely comfortable with it. The starting point is that people do not really often expect or want x^2 and x^-1 to be pow(x, 2) and pow(x, -1), respectively. Rather, people want x^2 to be syntax for x*x and x^-1 to be a syntax for 1/x. These can both generally be implemented much more efficiently than calling a general power function—but in completely different ways. With sufficiently clever optimizations (constant propagation + power reduction), one can potentailly optimize pow(x, 2) into x*x but it would be even better if we didn’t have to do such a clever optimization in the first place. It’s been a fairly common and successful strategy in the design of Julia to arrange things so that you can get great performance in a straightforward way without need for clever optimizations instead of trying to make the optimizers smarter. So what this design does is it causes x^n where n is a literal integer value to call Base.literal_pow(x, Val(n)), which allows us to specialize the syntax on individual literal values like 2 or -1. This allow us to make x^2 actually mean x*x instead of needing to try to optimize it to that. It also allows us to make negative literal exponents work without introducing a type instability in the general ^ function. And indeed, we used to get regular complaints from new users that 2^-1 doesn’t return 0.5 as they would expect, instead giving them a domain error because of the negative exponent. There are good reasons for it but users don’t care about involved language design reasons, they just want it to work. A way to think about this is that ^2 is its own operator, as is ^3 and ^-1, and so on. Hopefully that helps.