Cos'è l'Ultraradical

L' ultraradico , o il radicale Porta, di un numero reale è definito come l'unica radice reale dell'equazione quintica .$a$$x^5+x+a=0$

Qui usiamo per indicare la funzione ultraradica. Ad esempio, , poiché .$UR(\cdot)$$UR(-100010)=10$$10^5+10-100010=0$

Sfida

Scrivi un programma completo o una funzione, che accetta un numero reale come input e restituisce o emette il suo ultraradico.

Requisiti

Non sono ammesse scappatoie standard. I risultati per i seguenti casi di test devono essere precisi con almeno 6 cifre significative, ma in generale il programma dovrebbe calcolare i valori corrispondenti per tutti gli input di numeri reali validi.

Casi test

9 cifre decimali arrotondate verso 0 sono fornite come riferimento. È stata aggiunta una spiegazione per alcuni dei casi di test.

 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

Criteri vincenti

Vince l'invio valido più breve in ogni lingua.

Wolfram Language (Mathematica) , 20 byte

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

Provalo online!

È ancora integrato, ma almeno non lo è UltraRadical.

(il personaggio viene visualizzato come |->in Mathematica, simile a =>JS)

Python 3.8 (pre-release) , 60 byte

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

Provalo online!

Metodo di iterazione di Newton. $x' = x - \frac {f(x)} {f'(x)} = x - \frac {x^5+x+n} {5x^4+1}$

Durante l'utilizzo di $\frac {4x^5-n} {5x^4+1}$ è matematicamente equivalente, rende il ciclo del programma per sempre.

Altro approccio:

Python 3.8 (pre-release) , 102 byte

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)

Provalo online!

Ricerca binaria, dato che la funzione x^5+x+aè in aumento. Impostare i limiti su -abs(x)ed abs(x)è sufficiente ma -x*x-1ed x*x+1è più breve.

Il limite di ricorsione di BTW Python è un po 'troppo basso, quindi è necessario avere 1e-9, e :=si chiama operatore tricheco.

JavaScript (ES7), 44 byte

Una versione più sicura che utilizza la stessa formula di seguito ma con un numero fisso di iterazioni.

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

Provalo online!

JavaScript (ES7),  43  42 byte

Metodo di Newton, usando $5x^4+5$ come approssimazione di $f'(x)=5x^4+1$ .

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

Provalo online!

Come?

Iniziamo con $x_0=0$ e calcoliamo ricorsivamente:

fino a quando $x_k-x_{k+1}$ è insignificante.

Gelatina , 8 byte

;17B¤ÆrḢ

Provalo online!

Come funziona:

• Costruisce l'elenco [a, 1, 0, 0, 0, 1]anteponendo aalla rappresentazione binaria di 17. Perché questo elenco? Perché corrisponde ai coefficienti che stiamo cercando:

  [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
  

• Quindi, Ærè un built-in che risolve l'equazione polinomiale P(x) = 0, dato un elenco di coefficienti (quello che abbiamo costruito in precedenza).

• Siamo interessati solo alla soluzione reale, quindi prendiamo la prima voce nell'elenco delle soluzioni con Ḣ.

APL (Dyalog Unicode) , 11 10 byte ^SBCS

-1 grazie a dzaima

Funzione prefisso tacito anonimo.

(--*∘5)⍣¯1

Provalo online!

(... )⍣¯1 applica una volta la seguente funzione tacita negativa:

 - l'argomento negato

 - meno

 *∘5 l'argomento sollevato al potere di 5

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

R , 43 byte

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

Provalo online!

nlm è una funzione di ottimizzazione, quindi cerca il minimo della funzione $x\mapsto |x^5+x+a|$, ovvero l'unico zero. Il secondo parametro di nlmè il punto di inizializzazione. È interessante notare che l'inizializzazione su 0 non riesce per l'ultimo caso di test (presumibilmente a causa della precisione numerica), ma l'inizializzazione su a(che non è nemmeno il segno giusto) ha esito positivo.

R , 56 byte

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

Provalo online!

Thanks to @Roland for pointing out polyroot. I have also realised my previous answer picked a complex root for zero or negative $a$ so now rewritten using polyroot and filtering complex roots.

J, 14 bytes

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

Try it online!

J has a built in for solving polynomials... p.

The final 4 test cases timeout on TIO, but in theory are still correct.

how

The polynomial coefficients for J's builtin are taken as a numeric list, with the coefficient for x^0 first. This means the list is:

a 1 0 0 0 1

1 0 0 0 1 is 17 in binary, so we represent it as #:@17, then append the input ,, then apply p., then unbox the results with raze ;, then take the last element {:

Ruby, 53 41 bytes

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

Try it online!

Using Newton-Raphson with a fixed number of iterations, and the same approximation trick as Arnauld

Pari/GP, 34 32 26 24 bytes

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

Try it online!

05AB1E , 12 byte

ΔyIy4m>/+5/-

Provalo online!

Il metodo di Newton.

k4, 33 31 byte

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

newton-raphson ha calcolato iterativamente fino a quando un numero non è convergente

modifica: -2 grazie a ngn!

whoops, ho sbagliato tutto ...

K (oK), 10 byte

{-x+*/5#x}

Pari / GP , 24 byte

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

Provalo 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 byte con il nome della funzione originale e con una precisione aggiuntiva (doppia). Con gli hack bit potrebbe essere migliore, ma non portabile.

96 byte con iterazioni fisse.

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;}

In realtà, la nostra funzione è così buona che possiamo usare adattamenti migliori del metodo di Newton. L'implementazione sarebbe molto più rapida e pratica (150 byte)

#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;}

Ho controllato che funzioni, ma sono troppo pigro per scoprire quanto sarebbe più veloce. Dovrebbe essere almeno un altro ordine più veloce di quello di Newton.

Pulito , 61 60 byte

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

Provalo online!

Il metodo di Newton, implementato per la prima volta nella risposta di user202729 .

Pulito , 124 byte

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

Provalo online!

Una ricerca "binaria", restringendo l'area di ricerca al 99,6% superiore o inferiore dell'intervallo tra i limiti superiore e inferiore ad ogni iterazione anziché al 50%.

Python 3 + sympy, 72 byte

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

Provalo online!

Ottava , 25 byte

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

Provalo online!

Maplesoft Maple , 23 byte

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

Sfortunatamente, non esiste un compilatore / calcolatrice Maple online là fuori AFAIK. Ma il codice è piuttosto semplice.