O que é o Ultraradical

O ultraradical , ou o radical Bring, de um número real é definido como a única raiz real da equação quintica .$a$$x^5+x+a=0$

Aqui usamos para denotar a função ultradadical. Por exemplo, , já que .$UR(\cdot)$$UR(-100010)=10$$10^5+10-100010=0$

Desafio

Escreva um programa ou uma função completa, que aceite um número real como entrada e retorne ou produza seu ultradadical.

Exigências

Não são permitidas brechas padrão. Os resultados para os casos de teste abaixo devem ter precisão de pelo menos 6 dígitos significativos, mas, em geral, o programa deve calcular os valores correspondentes para quaisquer entradas válidas de números reais.

Casos de teste

9 casas decimais arredondadas para 0 são fornecidas como referência. A explicação é adicionada para alguns dos casos de teste.

 a                         | UR(a)
---------------------------+---------------------
             0             |   0.000 000 000        # 0
             1             |  -0.754 877 (666)      # UR(a) < 0 when a > 0
            -1             |   0.754 877 (666)      # UR(a) > 0 when a < 0
             1.414 213 562 |  -0.881 616 (566)      # UR(sqrt(2))
            -2.718 281 828 |   1.100 93(2 665)      # UR(-e)
             3.141 592 653 |  -1.147 96(5 385)      # UR(pi)
            -9.515 716 566 |   1.515 71(6 566)      # 5th root of 8, fractional parts should match
            10             |  -1.533 01(2 798)
          -100             |   2.499 20(3 570)
         1 000             |  -3.977 89(9 393)
      -100 010             |  10.000 0(00 000)      # a = (-10)^5 + (-10)
 1 073 741 888             | -64.000 0(00 000)      # a = 64^5 + 64

Critérios Vencedores

O menor envio válido em todos os idiomas vence.

Wolfram Language (Mathematica) , 20 bytes

Root[xx^5+x+#,1]&

Experimente online!

Ainda é um built-in, mas pelo menos não é UltraRadical.

(o caractere é exibido como |->no Mathematica, semelhante ao =>JS)

Python 3.8 (pré-lançamento) , 60 bytes

f=lambda n,x=0:x!=(a:=x-(x**5+x+n)/(5*x**4+1))and f(n,a)or a

Experimente online!

Método de iteração de Newton. $x' = x - \frac {f(x)} {f'(x)} = x - \frac {x^5+x+n} {5x^4+1}$

Ao usar $\frac {4x^5-n} {5x^4+1}$ é matematicamente equivalente, faz o programa repetir para sempre.

Outra abordagem:

Python 3.8 (pré-lançamento) , 102 bytes

lambda x:a(x,-x*x-1,x*x+1)
a=lambda x,l,r:r<l+1e-9and l or(m:=(l+r)/2)**5+m+x>0and a(x,l,m)or a(x,m,r)

Experimente online!

Pesquisa binária, considerando que a função x^5+x+aestá aumentando. Defina os limites para -abs(x)e abs(x)é suficiente, mas -x*x-1e x*x+1é mais curto.

O limite de recursão do BTW Python é um pouco baixo demais, por isso é necessário ter 1e-9, e isso :=é chamado de operador de morsa.

JavaScript (ES7), 44 bytes

Uma versão mais segura usando a mesma fórmula que abaixo, mas com um número fixo de iterações.

n=>(i=1e3,g=x=>i--?g(.8*x-n/(5*x**4+5)):x)``

Experimente online!

JavaScript (ES7),  43  42 bytes

Método de Newton, usando $5x^4+5$ como uma aproximação de $f'(x)=5x^4+1$ .

n=>(g=x=>x-(x-=(x+n/(x**4+1))/5)?g(x):x)``

Experimente online!

Quão?

Começamos com $x_0=0$ e computamos recursivamente:

até $x_k-x_{k+1}$ é insignificante.

Geléia , 8 bytes

;17B¤ÆrḢ

Experimente online!

Como funciona:

• Constrói a lista [a, 1, 0, 0, 0, 1]precedendo aa representação binária de 17. Por que essa lista? Porque corresponde aos coeficientes que procuramos:

  [a, 1, 0, 0, 0, 1] -> P(x) := a + 1*x^1 + 0*x^2 + 0*x^3 + 0*x^4 + 1*x^5 = a + x + x^5
  

• Então, Æré um built-in que resolve a equação polinomial P(x) = 0, dada uma lista de coeficientes (o que construímos anteriormente).

• Estamos interessados ​​apenas na solução real, portanto, fazemos a primeira entrada na lista de soluções Ḣ.

APL (Dyalog Unicode) , 11 10 bytes ^SBCS

-1 graças a dzaima

Função de prefixo tácito anônimo.

(--*∘5)⍣¯1

Experimente online!

(… )⍣¯1 Aplique a seguinte função tácita negativa uma vez:

 - o argumento negado

 - menos

 *∘5 o argumento levantado ao poder de 5

$x$$f(x)=-x-x^5$$y$

R , 43 bytes

function(a)nlm(function(x)abs(x^5+x+a),a)$e

Experimente online!

nlm$x\mapsto |x^5+x+a|$nlma

R , 56 bytes

function(x)(y=polyroot(c(x,1,0,0,0,1)))[abs(Im(y))<1e-9]

Experimente online!

polyroot$a$polyroot

J , 14 bytes

{:@;@p.@,#:@17

Experimente online!

J foi incorporado para resolver polinômios ... p.

Os 4 casos finais de teste atingiram o tempo limite no TIO, mas em teoria ainda estão corretos.

quão

Os coeficientes polinomiais para J embutidos são tomados como uma lista numérica, com o coeficiente para x^0primeiro. Isso significa que a lista é:

a 1 0 0 0 1

1 0 0 0 1é 17 em binário, então nós o representamos como #:@17, em seguida, anexamos a entrada ,, em seguida aplicamos p., em seguida, unbox os resultados com raze e ;, em seguida, pegue o último elemento{:

Ruby , 53 41 bytes

->a{x=a/=5;99.times{x-=a/(x**4+1)+x/5};x}

Experimente online!

Usando Newton-Raphson com um número fixo de iterações e o mesmo truque de aproximação que Arnauld

Pari / GP , 34 32 26 24 bytes

a->-solve(X=0,a,a-X-X^5)

Experimente online!

05AB1E , 12 bytes

ΔyIy4m>/+5/-

Experimente online!

Método de Newton.

k4, 33 31 bytes

{{y-(x+y+*/5#y)%5+5*/4#y}[x]/x}

newton-raphson computado iterativamente até que um número seja convergido em

edit: -2 graças a ngn!

gritos, entendi tudo errado ...

K (oK), 10 bytes

{-x+*/5#x}

Pari / GP , 24 bytes

a->polrootsreal(x^5+x+a)

Experimente online!

C, 118b / 96b

#include<math.h>
double ur(double a){double x=a,t=1;while(fabs(t)>1e-6){t=x*x*x*x;t=(x*t+x+a)/(5*t+1);x-=t;}return x;}

118 bytes com o nome da função original e com alguma precisão extra (dupla). Com bit hacks pode ser melhor, mas não portável.

96 bytes com iterações fixas.

double ur(double a){double x=a,t;for(int k=0;k<99;k++){t=x*x*x*x;x=(4*x*t-a)/(5*t+1);}return x;}

Na verdade, nossa função é tão boa que podemos usar melhores adaptações do método de Newton. Uma implementação muito mais rápida e prática (150 bytes) seria

#include<math.h>
double ur(double a){double x=a/5,f=1,t;while(fabs(f)>1e-6){t=x*x*x*x;f=(t*(5*t*x+5*a+6*x)+a+x)/(15*t*t-10*a*x*x*x+1);x-=f;}return x;}

Eu verifiquei se funciona, mas tenho preguiça de descobrir quanto mais rápido seria. Deve ser pelo menos mais um pedido mais rápido que o de Newton.

Limpo , 61 60 bytes

import StdEnv
$a=iter 99(\x=(3.0*x^5.0-a)/inc(4.0*x^4.0))0.0

Experimente online!

Método de Newton, implementado pela primeira vez na resposta do usuário202729 .

Limpo , 124 bytes

import StdEnv
$a= ?a(~a)with@x=abs(x^5.0+x+a);?u v|u-d==u=u|v+d==v=v= ?(u+if(@u< @v)0.0d)(v-if(@u> @v)0.0d)where d=(v-u)/3E1

Experimente online!

Uma pesquisa "binária", estreitando a área de pesquisa para 99,6% superior ou inferior do intervalo entre os limites alto e baixo em cada iteração, em vez de 50%.

Python 3 + sympy, 72 bytes

lambda y:float(sympy.poly("x**5+x+"+str(y)).all_roots()[0])
import sympy

Experimente online!

Oitava , 25 bytes

@(a)fzero(@(x)x^5+x+a,-a)

Experimente online!

Maplesoft Maple , 23 bytes

f:=a->fsolve(x^5+x+a=0)

Infelizmente, não há compilador / calculadora on-line do Maple disponível no AFAIK. Mas o código é bem direto.