prevent unnecessary repeated squaring calculation

[nsajko]

Fixes #58719

[github-actions]

Hello! I am a bot.

Thank you for your pull request!

I have assigned @vtjnash to this pull request.

@vtjnash can either choose to review this pull request themselves, or they can choose to find someone else to review this pull request.

Note: If you are a Julia committer, please make sure that your organization membership is public.

[nsajko]

Benchmark:

julia> using BenchmarkTools

julia> @btime m^Int(2) setup=m=rand(1:10,100,100);
  457.701 μs (6 allocations: 156.42 KiB)

julia> @eval Base @assume_effects :terminates_locally function power_by_squaring(x_, p::Integer; mul=*)
           [...]
       end
power_by_squaring (generic function with 3 methods)

julia> @btime m^Int(2) setup=m=rand(1:10,100,100);
  230.714 μs (3 allocations: 78.21 KiB)

[nsajko]

This PR currently breaks LazyArrays.jl, because LazyArrays.jl adds a method to the function to_power_type, even though to_power_type is not public. This PR currently keeps the function but leaves it unused, leading to an exception being thrown during exponentiation:

julia> using LazyArrays

julia> ApplyArray(exp, [1 2; 3 4]) ^ Int(2)
ERROR: MethodError: Cannot `convert` an object of type 
  ApplyArray{Float64,2,typeof(exp),Tuple{Matrix{Int64}}} to an object of type 
  ApplyArray{Float64,2,typeof(*),Tuple{ApplyMatrix{Float64, typeof(exp), Tuple{Matrix{Int64}}},ApplyMatrix{Float64, typeof(exp), Tuple{Matrix{Int64}}}}}
The function `convert` exists, but no method is defined for this combination of argument types.

Closest candidates are:
  (::Type{ApplyArray{T, N, F, Args}} where {T, N, F, Args<:Tuple})(::Any, ::Any)
   @ LazyArrays ~/.julia/packages/LazyArrays/ltmzk/src/lazyapplying.jl:196
  convert(::Type{T}, ::T) where T
   @ Base Base_compiler.jl:136
  convert(::Type{T}, ::LinearAlgebra.Factorization) where T<:AbstractArray
   @ LinearAlgebra ~/tmp/jl/jl/julia-e82b63cced/share/julia/stdlib/v1.13/LinearAlgebra/src/factorization.jl:104
  ...

Stacktrace:
 [1] power_by_squaring(x_::ApplyMatrix{Float64, typeof(exp), Tuple{Matrix{Int64}}}, p::Int64; mul::typeof(*))
   @ Base ./intfuncs.jl:361
 [2] power_by_squaring(x_::ApplyMatrix{Float64, typeof(exp), Tuple{Matrix{Int64}}}, p::Int64)
   @ Base ./intfuncs.jl:353
 [3] _power_by_squaring
   @ ~/.julia/packages/ArrayLayouts/B2wRU/src/mul.jl:486 [inlined]
 [4] power_by_squaring
   @ ~/.julia/packages/ArrayLayouts/B2wRU/src/mul.jl:494 [inlined]
 [5] ^(A::ApplyMatrix{Float64, typeof(exp), Tuple{Matrix{Int64}}}, p::Int64)
   @ LinearAlgebra ~/tmp/jl/jl/julia-e82b63cced/share/julia/stdlib/v1.13/LinearAlgebra/src/dense.jl:558
 [6] top-level scope
   @ REPL[2]:1

IMO the proper fix might be for LazyArrays.jl to implement their own exponentiation, however I could also try to make this PR less disruptive by using to_power_type conditionally, if applicable says that there's an applicable method. EDIT: the latter is now implemented.

[jishnub]

I don't think we should be checking for isapplicable, and such breakages are inevitable when a package uses internals. Patching LazyArrays is the better approach here.

[nsajko]

The current version of the PR doesn't use isapplicable and deletes the to_power_type function.

[nsajko]

bump

[oscardssmith]

This is somewhat ugly, but it seems reasonable enough.

[nsajko]

I suppose labelling as "merge me" is OK.

[nsajko]

TODO: notify affected packages of breakage.