The infinite power tower

Question

The challenge

Quite simple, given an input x, calculate it's infinite power tower!

x^x^x^x^x^x...

For you math-lovers out there, this is x's infinite tetration.

Keep in mind the following:

x^x^x^x^x^x... = x^(x^(x^(x^(x...)))) != (((((x)^x)^x)^x)^x...)

Surprised we haven't had a "simple" math challenge involving this!*

Assumptions

• x will always converge.
• Negative and complex numbers should be able to be handled
• This is code-golf, so lowest bytes wins!
• Your answers should be correct to at least 5 decimal places

Examples

Input >> Output

1.4 >> 1.8866633062463325
1.414 >> 1.9980364085457847
[Square root of 2] >> 2
-1 >> -1
i >> 0.4382829367270323 + 0.3605924718713857i
1 >> 1
0.5 >> 0.641185744504986
0.333... >> 0.5478086216540975
1 + i >> 0.6410264788204891 + 0.5236284612571633i
-i >> 0.4382829367270323 -0.3605924718713857i
[4th root of 2] >> 1.239627729522762

---

*(Other than a more complicated challenge here)

Answer 1

APL (Dyalog), 4 bytes

*⍣≡⍨

Try it online!

* power

⍣ until

≡ stable

⍨ selfie

Answer 2

Pyth,  4  3 bytes

^{crossed out 4 is still regular 4 ;(}

u^Q

Try it online

How it works

u       first repeated value under repeated application of G ↦
 ^QG        input ** G
    Q   starting at input

Answer 3

Haskell, 100 63 bytes

For inputs that don't converge (eg. -2) this won't terminate:

import Data.Complex
f x=until(\a->magnitude(a-x**a)<1e-6)(x**)x

Thanks a lot @ØrjanJohansen for teaching me about until and saving me 37 bytes!

Try it online!

Answer 4

Python 3, 40 39 35 bytes

• Thanks @Ørjan Johansen for a byte: d>99 instead of d==99: 1 more iteration for a lesser byte-count
• Thanks @Uriel for 4 bytes: wise utilization of the fact that x**True evaluates to x in x**(d>99or g(x,d+1)). The expression in the term evaluates to True for depth greater than 99 and thus returns the passed value.

Recursive lambda with a max-depth 100 i.e. for a depth 100 returns the same value. Actually is convergency-agnostic, so expect the unexpected for numbers with non-converging values for the function.

g=lambda x,d=0:x**(d>99or g(x,d+1))

Try it online!

Answer 5

Python 3, 37 30 27 bytes

-7 bytes from @FelipeNardiBatista.
-3 bytes from from @xnor

I don't remember much of Python anymore, but I managed to port my Ruby answer and beat the other Python 3 answer :D

lambda x:eval('x**'*99+'1')

Try it online!

Answer 6

Mathematica, 12 bytes

#//.x_:>#^x&

Takes a floating‐point number as input.

Answer 7

J, 5 bytes

^^:_~

Try it online!

Explanation

First, I'll show what command is being executed after parsing the ~ at the end, and the walk-through will be for the new verb.

(^^:_~) x = ((x&^)^:_) x

((x&^)^:_) x  |  Input: x
      ^:_     |  Execute starting with y = x until the result converges
  x&^         |    Compute y = x^y

Answer 8

C# (.NET Core), 79 78 bytes

x=>{var a=x;for(int i=0;i++<999;)a=System.Numerics.Complex.Pow(x,a);return a;}

Try it online!

I chose to iterate until i=999 because if I iterated until 99 some examples did not reach the required precision. Example:

Input:                      (0, 1)
Expected output:            (0.4382829367270323, 0.3605924718713857)
Output after 99 iterations: (0.438288569331222,  0.360588154553794)
Output after 999 iter.:     (0.438282936727032,  0.360592471871385)

As you can see, after 99 iterations the imaginary part failed in the 5th decimal place.

Input:                      (1, 1)
Expected output:            (0.6410264788204891, 0.5236284612571633)
Output after 99 iterations: (0.64102647882049,   0.523628461257164)
Output after 999 iter.:     (0.641026478820489,  0.523628461257163)

In this case after 99 iterations we get the expected precision. In fact, I could iterate until i=1e9 with the same byte count, but that would make the code considerably slower

• 1 byte saved thanks to an anonymous user.

Answer 9

Jelly, 5 bytes

³*$ÐL

Try it online!

Answer 10

Ruby, 21 20 bytes

->n{eval'n**'*99+?1}

Disclaimer: It seems that Ruby returns some weird values when raising a complex number to a power. I assume it's out of scope for this challenge to fix Ruby's entire math module, but otherwise the results of this function should be correct. Edit: Applied the latest changes from my Python 3 answer and suddenly it somehow gives the same, expected results :)

Try it online!

Answer 11

TI-BASIC, 16 bytes

The input and output are stored in Ans.

Ans→X
While Ans≠X^Ans
X^Ans
End

Answer 12

R, 36 33 bytes

-3 bytes thanks to Jarko Dubbeldam

Reduce(`^`,rep(scan(,1i),999),,T)

Reads from stdin. Reduces from the right to get the exponents applied in the correct order.

Try it (function)

Try it (stdin)

Answer 13

Javascript, 33 bytes

f=(x,y=x)=>(x**y===y)?y:f(x,x**y)

Answer 14

MATL, 20 10 bytes

cut down to half thanks to @LuisMendo

t^`Gw^t5M-

Try it online!

This is my first code-golf and my first time using MATL so i'm sure it could be easily outgolfed.

Answer 15

Perl 6, 17 bytes

{[R**] $_ xx 999}

Try it online!

R** is the reverse-exponentiation operator; x R** y is equal to y ** x. [R**] reduces a list of 999 copies of the input argument with reverse exponentiation.