Calculer l'ultraradical

24

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.

code-golf number polynomials

— Shieru Asakoto
source

Réponses:

12

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)

— user202729
source

9

Je me demande toujours pourquoi Mathematica utilise et au lieu de ↦etᵀ

— Adám

2

@ Adám suis-je censé juste voir des carrés pour les deux premiers, ou ai-je manqué une sorte de police ...

— mbrig

6

@mbrig Juste des carrés. C'est mon point. Mathematica utilise des caractères dans les zones d'utilisation privée même si Unicode en possède la plupart.

— Adám

8

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.

— user202729
source

Une recherche linéaire prendrait-elle moins d'octets?

— user202729

8

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:

x_{k + 1} = x_{k} - \frac{{x_{k}}^{5} + x_{k} + n}{5 {x_{k}}^{4} + 5} = x_{k} - \frac{x_{k} + \frac{n}{{x_{k}}^{4} + 1}}{5}

$x_{k+1}=x_k-\frac{{x_k}^5+x_k+n}{5{x_k}^4+5}=x_k-\frac{x_k+\frac{n}{{x_k}^4+1}}{5}$

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

— Arnauld
source

Étant donné que la comparaison de l'équivalence des nombres flottants est inexacte, je ne sais pas si la fin du programme peut être garantie pour chaque entrée possible (la réponse Python 3 ci-dessous a déjà rencontré des problèmes lors de la tentative de raccourcir la formule).

— Joel

1

@Joel J'ai ajouté une version plus sûre.

— Arnauld

7

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 Ḣ.

— M. Xcoder
source

6

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$ .

— Adam
source

C'est très cool. Malheureusement, J ne semble pas en mesure d'effectuer cette inversion

— Jonah

@dzaima Pourquoi n'ai-je pas vu ça? Merci.

— Adám

5

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

— Robin Ryder
source

@TheSimpliFire Mathématiquement, c'est équivalent, mais numériquement, ce n'est pas le cas: utiliser le carré au lieu de la valeur absolue conduit à la mauvaise valeur pour une entrée de grande taille. ( Essayez-le en ligne. )

— Robin Ryder

4

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

— Nick Kennedy
source

2

43 octets

— Robin Ryder

@RobinRyder qui est suffisamment différent pour que je pense que vous devriez publier votre propre réponse. Merci quand même!

— Nick Kennedy

1

OK merci. Ça y est .

— Robin Ryder

"Malheureusement", polyrootrenvoie toutes les racines complexes ... Sinon ça gagnerait.

— Roland

3

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

— Jonas
source

3

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

— GB
source

2

Pari / GP , 34 32 26 24 octets

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

Essayez-le en ligne!

— TheSimpliFire
source

Belle réponse, mais par curiosité: pourquoi le s(-100010)résultat au -8.090... - 5.877...*Ilieu de juste 10? Est-ce une limitation de la langue pour les grands cas de test? PS: Vous pouvez enregistrer 2 octets en changeant les deux 0.2en .2. :)

— Kevin Cruijssen

R^{-}

$\Bbb R^-$

Vous pouvez utiliser une fonction anonyme: a->solve(X=-a,a,X^5+X+a).

— alephalpha

Merci @alephalpha.

— TheSimpliFire

2

05AB1E , 12 octets

ΔyIy4m>/+5/-

Essayez-le en ligne!

La méthode de Newton.

— Grimmy
source

2

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}

— griffonner
source

@ngn lol, c'était imprudent ... mis à jour mais maintenant en k4 car je suis trop paresseux pour le faire en ngn / k ou oK :)

— scrawl

cool! la dernière paire de [ ]semble inutile

— ngn

hmm, tu as raison. J'ai déjà rencontré un comportement étrange où la sur / convergence aboutit à une boucle infinie à cause de crochets étrangers / omis (l'un ou l'autre, j'oublie). c'est pourquoi je les ai laissés mais j'aurais dû vérifier. Merci!

— gribouillage

1

Pari / GP , 24 octets

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

Essayez-le en ligne!

— alephalpha
source

Nice, ne savait pas qui solvea un analogue

— TheSimpliFire

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 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.

— sanaris
source

Souhaitez-vous quelque chose comme du x-=t=...travail?

— user202729

1

82 octets

— plafondcat

0

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%.

— Οurous
source

0

Python 3 + sympy, 72 octets

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

Essayez-le en ligne!

— Nick Kennedy
source

0

Octave , 25 octets

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

Essayez-le en ligne!

— tsh
source

0

É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.

— polfosol ఠ_ఠ
source

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.

Licensed under cc by-sa 3.0 with attribution required.