Qu'est-ce que l'Ultraradical

L' ultraradical , ou le radical Bring, d'un nombre réel est défini comme la seule vraie racine de l'équation quintique .$a$$x^5+x+a=0$

Ici, nous utilisons pour désigner la fonction ultraradicale. Par exemple, , puisque .$UR(\cdot)$$UR(-100010)=10$$10^5+10-100010=0$

Défi

Écrivez un programme complet ou une fonction, qui prend un nombre réel en entrée, et retourne ou sort son ultraradical.

Exigences

Aucune échappatoire standard n'est autorisée. Les résultats pour les cas de test ci-dessous doivent être précis à au moins 6 chiffres significatifs, mais en général, le programme doit calculer les valeurs correspondantes pour toute entrée de nombre réel valide.

Cas de test

9 décimales arrondies vers 0 sont données à titre de référence. Une explication est ajoutée pour certains des cas de 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

Critères gagnants

La soumission valide la plus courte dans toutes les langues gagne.

Wolfram Language (Mathematica) , 20 octets

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

Essayez-le en ligne!

Toujours intégré, mais au moins ce n'est pas le cas UltraRadical.

(le personnage est affiché comme |->dans Mathematica, similaire à =>JS)

Python 3.8 (pré-version) , 60 octets

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

Essayez-le en ligne!

Méthode d'itération de Newton. $x' = x - \frac {f(x)} {f'(x)} = x - \frac {x^5+x+n} {5x^4+1}$

En utilisant $\frac {4x^5-n} {5x^4+1}$ est mathématiquement équivalent, cela fait que le programme boucle pour toujours.

Autre approche:

Python 3.8 (pré-version) , 102 octets

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)

Essayez-le en ligne!

Recherche binaire, étant donné que la fonction x^5+x+aaugmente. Fixez les limites à -abs(x)et abs(x)est suffisant mais -x*x-1et x*x+1est plus court.

La limite de récursivité de BTW Python est un peu trop basse, il est donc nécessaire d'avoir 1e-9, et :=s'appelle l'opérateur morse.

JavaScript (ES7), 44 octets

Une version plus sûre utilisant la même formule que ci-dessous mais avec un nombre fixe d'itérations.

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

Essayez-le en ligne!

JavaScript (ES7),  43  42 octets

Méthode de Newton, utilisant $5x^4+5$ comme approximation de $f'(x)=5x^4+1$ .

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

Essayez-le en ligne!

Comment?

Nous commençons par $x_0=0$ et calculons récursivement:

jusqu'à ce que $x_k-x_{k+1}$ soit insignifiant.

Gelée , 8 octets

;17B¤ÆrḢ

Essayez-le en ligne!

Comment ça marche:

• Construit la liste [a, 1, 0, 0, 0, 1]en ajoutant ala représentation binaire de 17. Pourquoi cette liste? Parce qu'elle correspond aux coefficients que nous recherchons:

  [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
  

• Ensuite, Ærest un intégré qui résout l'équation polynomiale P(x) = 0, étant donné une liste de coefficients (ce que nous avons construit plus tôt).

• Nous ne sommes intéressés que par la vraie solution, nous prenons donc la première entrée dans la liste des solutions avec Ḣ.

APL (Dyalog Unicode) , 11 10 octets ^SBCS

-1 grâce à dzaima

Fonction de préfixe tacite anonyme.

(--*∘5)⍣¯1

Essayez-le en ligne!

(…)⍣¯1  Appliquer une fois la fonction tacite négative négative:

 - l'argument nié

 - moins

 *∘5 l'argument porté à la puissance de 5

Essentiellement, cela demande: quel $x$ dois-je fournir à $f(x)=-x-x^5$ sorte que le résultat devienne $y$ .

R , 43 octets

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

Essayez-le en ligne!

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

R , 56 octets

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

Essayez-le en ligne!

polyroot$a$polyroot

J , 14 octets

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

Essayez-le en ligne!

J a un intégré pour résoudre les polynômes ... p.

Le délai d'expiration des 4 derniers tests sur TIO, mais en théorie, est toujours correct.

Comment

Les coefficients polynomiaux pour la fonction intégrée de J sont pris comme une liste numérique, avec le coefficient pour le x^0premier. Cela signifie que la liste est:

a 1 0 0 0 1

1 0 0 0 1est 17 en binaire, donc nous le représentons comme #:@17, puis ajoutons l'entrée ,, puis appliquons p., puis déballons les résultats avec raze ;, puis prenons le dernier élément{:

Rubis , 53 41 octets

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

Essayez-le en ligne!

Utiliser Newton-Raphson avec un nombre fixe d'itérations, et la même astuce d'approximation qu'Arnauld

Pari / GP , 34 32 26 24 octets

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

Essayez-le en ligne!

05AB1E , 12 octets

ΔyIy4m>/+5/-

Essayez-le en ligne!

La méthode de Newton.

k4, 33 31 octets

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

newton-raphson calculé itérativement jusqu'à ce qu'un nombre converge

edit: -2 grâce à ngn!

whoops, tout cela est faux ...

K (oK), 10 octets

{-x+*/5#x}

Pari / GP , 24 octets

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

Essayez-le en ligne!

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 octets avec le nom de la fonction d'origine et avec une précision supplémentaire (double). Avec un peu de piratage peut être mieux, mais non transférable.

96 octets avec itérations fixes.

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

En fait, notre fonction est si bonne que nous pouvons utiliser de meilleures adaptations de la méthode de Newton. Une mise en œuvre beaucoup plus rapide et pratique (150 octets) serait

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

J'ai vérifié que cela fonctionne, mais je suis trop paresseux pour savoir à quel point ce serait plus rapide. Devrait être au moins une commande plus rapide que celle de Newton.

Nettoyer , 61 60 octets

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

Essayez-le en ligne!

La méthode de Newton, d'abord implémentée dans la réponse de user202729 .

Nettoyer , 124 octets

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

Essayez-le en ligne!

Une recherche "binaire", rétrécissant la zone de recherche à 99,6% supérieur ou inférieur de la plage entre les limites hautes et basses à chaque itération au lieu de 50%.

Python 3 + sympy, 72 octets

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

Essayez-le en ligne!

Octave , 25 octets

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

Essayez-le en ligne!

Érable Maplesoft , 23 octets

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

Malheureusement, il n'y a pas de compilateur / calculateur Maple en ligne là-bas AFAIK. Mais le code est assez simple.