Was ist der Ultraradikal

Der Ultraradikal oder das Bring-Radikal einer reellen Zahl $a$ ist definiert als die einzige reelle Wurzel der Quintingleichung $x^5+x+a=0$ .

Hier verwenden wir $UR(\cdot)$ , um die Ultraradikalfunktion zu bezeichnen. Zum Beispiel ist , da .$UR(-100010)=10$$10^5+10-100010=0$

Herausforderung

Schreiben Sie ein vollständiges Programm oder eine Funktion, die eine reelle Zahl als Eingabe verwendet und deren Ultraradikal zurückgibt oder ausgibt.

Bedarf

Es sind keine Standardlücken erlaubt. Die Ergebnisse für die folgenden Testfälle müssen auf mindestens 6 signifikante Stellen genau sein. Im Allgemeinen sollte das Programm jedoch die entsprechenden Werte für alle gültigen reellen Zahleneingaben berechnen.

Testfälle

Als Referenz werden 9 auf 0 gerundete Dezimalstellen angegeben. Für einige Testfälle wurde eine Erklärung hinzugefügt.

 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

Gewinnkriterien

Die kürzeste gültige Einsendung in jeder Sprache gewinnt.

Wolfram Language (Mathematica) , 20 Byte

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

Probieren Sie es online!

Immer noch eingebaut, aber zumindest nicht UltraRadical.

(Das Zeichen wird wie |->in Mathematica angezeigt , ähnlich wie =>in JS)

Python 3.8 (Vorabversion) , 60 Byte

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

Probieren Sie es online!

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

Bei Verwendung von $\frac {4x^5-n} {5x^4+1}$ ist mathematisch äquivalent, es macht die Programmschleife für immer.

Anderer Ansatz:

Python 3.8 (Vorabversion) , 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)

Probieren Sie es online!

Binäre Suche, da die Funktion x^5+x+azunimmt. Setzen Sie die Grenzen auf -abs(x)und abs(x)ist ausreichend, aber -x*x-1und x*x+1ist kürzer.

BTW Pythons Rekursionslimit ist etwas zu niedrig, daher ist 1e-9 erforderlich, und der :=wird als Walrossoperator bezeichnet.

JavaScript (ES7), 44 Byte

Eine sicherere Version mit der gleichen Formel wie unten, jedoch mit einer festen Anzahl von Iterationen.

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

Probieren Sie es online!

JavaScript (ES7),  43  42 Bytes

Newtonsche Methode unter Verwendung von $5x^4+5$ als Approximation von $f'(x)=5x^4+1$ .

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

Probieren Sie es online!

Wie?

Wir beginnen mit $x_0=0$ und berechnen rekursiv:

bis $x_k-x_{k+1}$ ist unbedeutend.

Gelee , 8 Bytes

;17B¤ÆrḢ

Probieren Sie es online!

Wie es funktioniert:

• [a, 1, 0, 0, 0, 1]Erstellt die Liste, indem ader binären Darstellung von vorangestellt wird 17. Warum diese Liste? Weil es den Koeffizienten entspricht, die wir suchen:

  [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
  

• Dann Ærist ein eingebautes, das die Polynomgleichung löst P(x) = 0, gegeben eine Liste der Koeffizienten (was wir vorher konstruiert haben).

• Wir interessieren uns nur für die reale Lösung, deshalb nehmen wir den ersten Eintrag in der Liste der Lösungen mit Ḣ.

APL (Dyalog Unicode) , 11 10 Bytes ^SBCS

-1 danke an dzaima

Anonyme implizite Präfixfunktion.

(--*∘5)⍣¯1

Probieren Sie es online!

(… )⍣¯1 Wenden Sie einmal die folgende implizite Funktion negativ an:

 - das negierte Argument

 - Minus

 *∘5 das Argument zur Potenz von 5 erhoben

Im Wesentlichen fragt dies: Welches $x$ muss ich $f(x)=-x-x^5$ so zuführen, dass das Ergebnis wird$y$

R , 43 Bytes

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

Probieren Sie es 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]

Probieren Sie es online!

polyroot$a$polyroot

J , 14 Bytes

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

Probieren Sie es online!

J hat eine eingebaute für die Lösung von Polynomen ... p.

Die letzten 4 Testfälle haben eine Zeitüberschreitung bei TIO, sind aber theoretisch immer noch korrekt.

Wie

Die Polynomkoeffizienten für Js Builtin werden als numerische Liste mit dem Koeffizienten für x^0first verwendet. Das heißt, die Liste ist:

a 1 0 0 0 1

1 0 0 0 1ist 17 in binär, also stellen wir es so dar #:@17, fügen dann die Eingabe hinzu ,, wenden p.dann an, entpacken die Ergebnisse mit raze ;und nehmen dann das letzte Element{:

Ruby , 53 41 Bytes

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

Probieren Sie es online!

Verwendung von Newton-Raphson mit einer festen Anzahl von Iterationen und demselben Approximationstrick wie Arnauld

Pari / GP , 34 32 26 24 Bytes

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

Probieren Sie es online!

05AB1E , 12 Bytes

ΔyIy4m>/+5/-

Probieren Sie es online!

Newtons Methode.

k4, 33 31 Bytes

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

Newton-Raphson wird iterativ berechnet, bis eine Zahl konvergiert

edit: -2 danke an ngn!

Hoppla, alles falsch gemacht ...

K (oK), 10 Bytes

{-x+*/5#x}

Pari / GP , 24 Bytes

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

Probieren Sie es 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 mit dem ursprünglichen Funktionsnamen und einer gewissen zusätzlichen Genauigkeit (doppelt). Mit Bit-Hacks ist es vielleicht besser, aber nicht portierbar.

96 Bytes mit festen Iterationen.

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

Tatsächlich ist unsere Funktion so gut, dass wir die Newtonsche Methode besser anpassen können. Eine viel schnellere und praktischere Implementierung (150 Bytes) wäre

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

Ich habe überprüft, ob es funktioniert, aber ich bin zu faul, um herauszufinden, wie viel schneller es sein würde. Sollte mindestens eine weitere Bestellung schneller sein als Newtons.

Sauber , 61 60 Bytes

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

Probieren Sie es online!

Newtons Methode, die zuerst in der Antwort von user202729 implementiert wurde .

Sauber , 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

Probieren Sie es online!

Eine "binäre" Suche, bei der der Suchbereich bei jeder Iteration auf die oberen oder unteren 99,6% des Bereichs zwischen den oberen und unteren Grenzen anstatt auf 50% eingeschränkt wird.

Python 3 + Sympy, 72 Bytes

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

Probieren Sie es online!

Oktave , 25 Bytes

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

Probieren Sie es online!

Maplesoft Maple , 23 Bytes

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

Leider gibt es keinen Online-Maple-Compiler / Taschenrechner von AFAIK. Aber der Code ist ziemlich einfach.