I did a major rewrite after reading up on pow works. This is now replaced by exp, which makes it much faster on x86 and shouldn't make much change on other platforms (exp shouldn't be worse than pow).

Added some comments about how it is refactored.

For my test example, similar to #24908 (comment), the time doing pow was 33% of the total time, now the time doing exp is 16% of the total time. (Hard to compare actual times as the workloads were slightly different on the machine...)

One may want to move the random number generation and exp into the if-clause. However, that may change the outcome, although I guess that the if-clause is primarily for avoiding division by zero in rare cases rather than something that is heavily used, so there may be limited performance benefits and limited changes in the outcome.

Edit: I guess what I am trying to say is that if there is a performance benefit of moving it there, it will also modify the output to a larger extent as what we are doing is skipping updating the phase and random sequence when len is 0. So probably not a good idea.

Is this code path tested? Do you have evidence that this is actually a speed up?

We will hit this in : https://github.com/matplotlib/matplotlib/blob/main/lib/matplotlib/tests/baseline_images/test_path/xkcd.png

I'm happy to take Oscar at his word that this is faster.

Yes. it is faster (and tested). At least on x86, but shouldn't be slower on other architectures (as in about as fast, worst case). The background is that pow(a, b) is computed as exp(b*log(a)) internally on x86 (as there are exp and log instructions). Since a is constant in this case, one can compute log(a) once.

(Been focusing quite heavily on a work project recently...)