Berechnen Sie den Ultraradikalen


24

Was ist der Ultraradikal

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

Hier verwenden wir UR() , um die Ultraradikalfunktion zu bezeichnen. Zum Beispiel ist , da .UR(-100010)=10105+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.

Antworten:


12

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)


9
Ich frage mich immer wieder, warum Mathematica und anstelle von und verwendet
Adám

2
@ Adám soll ich nur Quadrate für die ersten beiden sehen, oder vermisse ich eine Art Schrift ...
mbrig

6
@mbrig Nur Quadrate. Das ist mein Punkt. Mathematica verwendet Zeichen in den Bereichen für den privaten Gebrauch , obwohl Unicode über die meisten davon verfügt.
Adám

8

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-f(x)f(x)=x-x5+x+n5x4+1

Bei Verwendung von 4x5-n5x4+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.


Würde eine lineare Suche weniger Bytes benötigen?
user202729

8

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 5x4+5 als Approximation von f(x)=5x4+1 .

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

Probieren Sie es online!

Wie?

Wir beginnen mit x0=0 und berechnen rekursiv:

xk+1=xk-xk5+xk+n5xk4+5=xk-xk+nxk4+15

bis xk-xk+1 ist unbedeutend.


Da der Vergleich der Äquivalenz von Gleitkommazahlen ungenau ist, bin ich mir nicht sicher, ob das Beenden des Programms für jede mögliche Eingabe garantiert werden kann (die Antwort in Python 3 unten zeigt bereits Probleme beim Versuch, die Formel zu verkürzen).
Joel

1
@ Joel Ich habe eine sicherere Version hinzugefügt.
Arnauld

7

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 .


6

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-x5 so zuführen, dass das Ergebnis wirdy


Das ist sehr cool. Leider scheint J diese Inversion nicht ausführen zu können
Jonah

@dzaima Warum habe ich das nicht gesehen? Danke.
Am



3

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{:



2

Pari / GP , 34 32 26 24 Bytes

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

Probieren Sie es online!


Nizza Antwort, aber aus Neugier: warum tut s(-100010)Ergebnis in -8.090... - 5.877...*Ianstatt nur 10? Ist dies eine Einschränkung der Sprache für große Testfälle? PS: Sie können 2 Bytes speichern, indem Sie beide 0.2in ändern .2. :)
Kevin Cruijssen

R-

Sie können eine anonyme Funktion verwenden: a->solve(X=-a,a,X^5+X+a).
Alephalpha

Danke @alephalpha.
TheSimpliFire


2

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}

@ngn lol, das war nachlässig ... aktualisiert, aber jetzt in k4, da ich zu faul bin, es in ngn / k oder oK zu tun :)
Scrawl

cool! das letzte Paar [ ]scheint unnötig
ngn

hmm, du hast recht. Ich habe schon einmal seltsames Verhalten erlebt, bei dem Über / Konvergieren zu einer Endlosschleife führt, weil (ich vergesse, das eine oder andere) überflüssige / ausgelassene Klammern verwendet werden. Deshalb habe ich sie hier gelassen, aber ich hätte es überprüfen sollen. Vielen Dank!
Scrawl


1

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.


Möchten Sie etwas x-=t=...arbeiten?
user202729


0

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.




Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.