Le nombre approximatif de plastique


24

Le défi

Le nombre plastique est un nombre lié au nombre d'or, avec de nombreuses propriétés mathématiques intéressantes. En tant que tel, il existe de nombreuses approches qui peuvent être utilisées pour calculer le nombre.

Afin de spécifier précisément le nombre aux fins de ce défi, nous utiliserons la définition suivante (bien qu'il existe de nombreuses définitions équivalentes, et vous pouvez utiliser n'importe quelle définition de votre choix tant qu'il s'agit du même nombre):

Le nombre plastique est un nombre réel ρ tel que ρ ³ = ρ +1.

Votre défi consiste à écrire un programme ou une fonction qui prend un entier x en entrée (avec x > 1), et produit une approximation de ρ en sortie, de sorte que plus la valeur de x est grande, plus la sortie se rapproche de ρ ( avec au maximum un nombre infini d'exceptions; rester à la même valeur compte comme "plus proche" à cet effet), et pour tout nombre positif δ , il y a une entrée x dans votre programme qui produit une sortie qui est à moins de δ de ρ .

Clarifications

  • Si vous effectuez une sortie via une méthode qui génère de manière inhérente des chaînes (par exemple le flux de sortie standard), vous pouvez formater la sortie soit en décimal (par exemple 1.3247179572), soit comme un rapport de deux entiers avec un /caractère entre eux.
  • Si vous générez une valeur dans votre langage de programmation (par exemple, en revenant d'une fonction), elle doit être de type à virgule fixe, à virgule flottante ou rationnelle. (En particulier, vous ne pouvez pas utiliser des types de données qui stockent des nombres symboliquement, à moins qu'ils ne soient utilisés que pour maintenir le rapport de deux entiers. Donc, si vous utilisez Mathematica ou un langage similaire, vous devrez inclure le supplément pour générer réellement les chiffres de la sortie.)
  • Votre réponse doit fonctionner dans une variante hypothétique de votre langue dans laquelle les entiers peuvent être arbitrairement grands et la mémoire (y compris la pile) est illimitée. Vous ne pouvez pas supposer que l'arithmétique à virgule flottante dans votre langue est arbitrairement précise, mais devez plutôt utiliser sa précision réelle (ce qui signifie que la sortie d'un nombre à virgule flottante ne sera possible que dans les langues où la précision des nombres à virgule flottante peut être contrôlé à l'exécution).
  • x peut avoir la signification que vous voulez (tant que l'augmentation donne des sorties plus précises). J'imagine que la plupart des soumissions le feront contrôler le nombre de chiffres de sortie à produire, ou le nombre d'itérations de l'algorithme utilisé par votre programme pour converger sur le nombre plastique, mais d'autres significations sont acceptables.

Cas de test

Voici les premiers chiffres du numéro en plastique:

1.32471795724474602596090885

Plus de chiffres sont disponibles sur OEIS .

Condition de victoire

Comme d'habitude pour le , plus court est meilleur, mesuré en octets. Cependant, n'hésitez pas à publier des réponses même si elles ne gagnent pas, tant qu'elles ajoutent quelque chose (par exemple une langue différente ou un algorithme différent) aux réponses existantes.


1
hmm, (cbrt (108 + 12 * sqrt (69)) + cbrt (108-12 * sqrt (69))) / 6 cela semble être le bon moment pour utiliser `l'approximation Drake ': sqrt (69) = 8. quelque chose bit.ly/2rCqedX ^ _ ^
DrQuarius

2
Pouvons-nous également supposer que la profondeur de récursivité / pile est illimitée?
xnor

Pour clarifier le deuxième point, pouvons-nous utiliser des bibliothèques de précision arbitraires (par exemple mpmath en Python)? Ils utilisent un type de données auxiliaire, mais considérez-vous cela comme stockant des choses "symboliquement"?
Batman

1
Eh bien, à tout le moins, je m'attends à ce que les réponses convergent vers ρ . De plus, une solution "honnête" pourrait facilement échouer au test x> y -> | ρx - ρ | > | ρy - ρ | pour un nombre fini de paires (x, y) . Si ce n'est pas acceptable, je pense que cela devrait être rendu plus explicite dans la spécification.
Dennis

6
De nombreux répondeurs sont tombés dans le piège (?) Du calcul d'une approximation à x chiffres de ρ, le problème étant qu'il existe probablement une infinité de x telle qu'une approximation à (x + 1) chiffres n'est pas meilleure qu'une approximation à x chiffres. Vous devriez probablement préciser si vous vouliez que cela soit autorisé. Si vous ne le faites pas, remplacez «plus près» par «strictement plus près»; si vous le faites, «au moins aussi près», ou quelque chose. Vous pouvez également considérer l'exigence plus lâche que la séquence converge vers ρ, ce qui permettrait en outre la réponse de xnor.
Anders Kaseorg

Réponses:


10

Python 2 , 49 octets

n=x=input()
while n**3/x/x<n+x:n+=1
print n,'/',x

Essayez-le en ligne!

L'idée est d'exprimer le ρavec ρ³=ρ+1comme une fraction n/xdont le dénominateur xest le paramètre de précision d'entrée. Nous prenons (n/x)³=n/x+1et dégageons les dénominateurs à obtenir n³=x²(x+n).

Étant donné que le LHS augmente nplus rapidement que le RHS, nous pouvons approximer le point d'égalité ncomme le plus petit avec n³≥x²(x+n). Le code compte njusqu'à ce que ce soit le cas, à partir xduquel il est plus petit.

Un petit octet de sauvegarde consiste à diviser les deux côtés en écriture n³/x²≥x+n(annulé dans la whilecondition). Il s'agit de la division du plancher dans le code, mais la partie fractionnelle perdue est négligeable.

Une alternative de même longueur met xà la place comme numérateur:

Python 2 , 49 octets

n=x=input()
while x**3/n/n<n+x:n-=1
print x,'/',n

Essayez-le en ligne!


Bien que cette sortie converge vers ρ (∀ε> 0 ∃x₀ ∀x ≥ x₀ | f (x) - ρ | <ε), elle ne satisfait pas «plus la valeur de x est grande, plus la sortie se rapproche de ρ (avec au maximum un nombre fini d'exceptions) »(∃x₀ ∀x ≥ x₀ | f (x + 1) - ρ | <| f (x) - ρ |).
Anders Kaseorg

Ce problème peut être résolu en utilisant 2**input()plutôt que simplement input(); ensuite, chaque approximation sera au moins aussi précise que la précédente.

10

Mathematica, 20 octets

#^3-#-1&~Root~1~N~#&

La Rootfonction intégrée de Mathematica donne les solutions d'une équation polynomiale f[x] == 0.

Explication

#^3-#-1&~Root~1~N~#&
                   &  (* Function *)
#^3-#-1&              (* A pure-function polynomial, x^3-x-1 *)
        ~Root~1       (* Find the first root *)
               ~N~#   (* approximate to (input) digits *)

Exemple d'E / S

In[1]:= f=#^3-#-1&~Root~1~N~#&;
        f[1]

Out[1]= 1.

In[2]:= f[9]

Out[2]= 1.32471796

In[3]:= f[100]

Out[3]= 1.324717957244746025960908854478097340734404056901733364534015050302827851245547594054699347981787280

PS: Root[x^3-x-1,1]~N~#&fonctionne très bien (bien que je ne dise pas que xc'est une variable) pour le même nombre d'octets.
Greg Martin

@AndersKaseorg: J'ai changé cette règle car elle était clairement enfreinte. Aucune réponse valide n'a été invalidée, mais certaines réponses (comme celle-ci) sont devenues valides.

6

Mathematica, 27 octets

x/.Solve[x^3==x+1>2,x]~N~#&

-1 octet de Martin
-2 octets de ovs

contribution

[27]

sortie

{1.32471795724474602596090885}


Solve[x^3==x+1>2,x]~N~#&pour 24 octets
ovs

1
Le résultat est {{x -> 1.32...}}cependant. Vous voudrez peut-être vérifier avec ais si c'est un format de sortie valide.
Martin Ender

ok .. tout est résolu je suppose
J42161217

C'est toujours en {1.32...}fait, mais ce format est probablement moins litigieux.
Martin Ender

1
J'ai rendu le défi un peu plus général pour que cela soit valide, il n'était pas destiné à interdire les solutions "premiers x chiffres". Donc, c'est valable maintenant, même si ce n'était pas le cas auparavant.

6

sed , 67 60 (59 + 1) octets

s,^,1/1/1 ,
:;s,(1*/(1*)/(1*).*)1$,\2\3/\1,
t
s,(/1*).*,\1,

Essayez-le en ligne!

+1 pour le -Edrapeau (ERE au lieu de BRE). L'entrée et la sortie sont toutes les deux unaires: entrée 11111 pour x = 5, par exemple, la sortie est une fraction de deux nombres unaires: l'entrée 11111 susmentionnée donne la sortie 11111/1111 (5/4 en décimal).

Approximation du nombre de plastique sous forme de fraction entre les éléments consécutifs de la séquence Padovan .


1
FWIW vous n'avez pas besoin d'espace après la bcommande, mais vous pouvez la raccourcir encore en utilisant l'étiquette vide ( :et bsans argument). tio.run/#%23K05N@f@/…
Jordanie

Oh excellent. Et je peux enregistrer encore 4 octets en utilisant à la tplace de b, c'est donc une sauvegarde plutôt sympa. Merci :)
FireFly

5

Mathematica, 27 octets

Nest[(1+#)^(1/3)&,1,#]~N~#&

Utilise une approximation tronquée de la forme du radical cubique imbriqué ³√ (1 + ³√ (1 + ³√ (1 + ...))) . Bien que la sortie contienne toujours x-1 décimales, le résultat est en fait moins précis que cela, car l'expression converge plus lentement qu'un chiffre par itération ( x est également utilisé comme nombre de radicaux imbriqués calculés). Par exemple, x = 100 donne

_________________________________________________________________________
1.324717957244746025960908854478097340734404056901733364534015050302827850993693624204577670741656151

où la partie soulignée est correcte.


Je prévoyais d'écrire cet algorithme dc, mais j'ai été bloqué car il s'avère qu'il n'a pas d'opération de racine cubique, et augmenter un nombre à la puissance ⅓ ne fonctionne pas non plus :-( Au moins, vous pouvez toujours compter sur Mathematica disposera de modules internes appropriés

3
@ ais523 Il y a en fait CubeRootmais personne n'a d'octets pour ça.
Martin Ender

4

Octave , 50 octets

@(n)char(digits(n)*0+vpasolve(sym('r^3-r-1'))(1));

Essayez-le en ligne!

Définit une fonction anonyme, avec nle nombre souhaité de chiffres de sortie.

Cette réponse abuse qui digitsrenvoie le paramètre actuel pour le nombre de chiffres dans l'arithmétique à précision variable. Cela signifie que nous pouvons simplement l'utiliser dans une fonction anonyme sans erreur sur «Trop d'arguments de sortie».

En dehors de cela, c'est vraiment simple: vpasolveest l'abréviation de Résolution arithmétique à précision variable, avec la précision définie par le dernier appel de digits. Comme il vpas'agit d'un type de données symbolique dans Octave, qui est interdit par la spécification, nous enveloppons simplement la fonction entière char(...)pour obtenir une sortie de chaîne. Notez que dans solveet vpasolve, le f==0est implicite, a donc r^3==r+1été remplacé parr^3-r-1 (==0)


Je suis allé et j'ai changé la question pour qu'elle n'interdise pas les réponses comme ça (ce n'était pas censé le faire).

@ ais523 Merci pour la notification!
Sanchises

4

MATL ( 27 28 octets)

7BG:"t@)y@Q)+h]tG3+)yG2+)/

Ma première solution (27 octets)

Essayez-le en ligne!

Ce n'est certainement pas optimal, je m'habitue toujours à MATL.

Explication:

Je crée une séquence Padovan jusqu'à l'entrée + 3 puis trouve le rapport des deux derniers nombres.

7B     % Turn 7 into binary to give 1 1 1 
G:"    % For k=1:input do...
t@)    % Existing sequence member k
y@1+)  % Existing sequence member k+1
+h     % Add them together and concatenate to the sequence array
]      % End loop
tG3+)  % Final sequence member
yG2+)  % Second last sequence member
/      % Divide to approximate ρ

Sortie de fraction appropriée (35 octets) (28 octets, @Sanchises):

Cependant, la première solution ne répond pas au besoin de précision arbitraire étant la limite à virgule flottante des paramètres MATL par défaut. Ainsi, plutôt que d'ajouter plusieurs octets pour étendre cette précision, il est plus simple de prendre la route de fraction appropriée et d'écrire une fraction des deux derniers nombres entiers dans les (N-1) ème et N ème éléments de la séquence Padovan tronquée.

par exemple "114/86"

7BG: "t @) y @ 1 +) + h] tG3 +) V '/' YcyG2 +) VYc

7BG:"t@tQh)sh]tJ)V47hyJq)Vh&

Avec l'aimable autorisation de l'utilisateur @Sanchises. :)

Essayez-le en ligne!

Évaluation non itérative:

Notamment, mon code le plus court pour la version «exacte» est (23 octets):

1-1h69X^12**108+1I/^6/s

Essayez-le en ligne!

... mais ne donne pas de précision arbitraire. Je me demande si quelqu'un peut ajuster cela pour respecter les règles (utiliser l'entrée, etc.) et ajouter encore moins de 5 octets? : P


1
1+peut être raccourci à. QAvec cela à l'esprit, vous pouvez remplacer @)y@1+)+par juste @tQh)s. De plus, vous pouvez utiliser Jpour indiquer la fin d'un tableau; et enfin, MATL ne fait pas de distinction entre les tableaux normaux et les tableaux de caractères, vous pouvez donc les remplacer Ycpar h(vous n'avez pas besoin des fonctionnalités supplémentaires de Yc). Cela donne seulement 28 octets: 7BG:"t@tQh)sh]tJ)V47hyJq)Vh&(notez le &pour éviter une sortie superflue et remplacez-le '/'par 47).
Sanchises

1
Bravo pour le 7Bbien, bien mieux que de pousser naïvementlllv
Sanchises

1
@DrQuarius La dernière version peut toujours être trouvée dans ce lien GitHub
Luis Mendo

1
@DrQuarius Non, ce comportement est présent dans les spécifications MATL plutôt anciennes que j'utilise généralement. Vous devriez vraiment consulter le tableau 3. Non seulement le presse-papiers Jcontient par défaut 1j, mais le presse-papiers Lcontient également de nombreuses fonctions d'indexation utiles (notez que c'est 1jégal enden MATL).
Sanchises

1
Ne vous inquiétez pas, je suis ingénieur en mécanique. Je pense que MATL (AB) a peu d'utilité en dehors d'un environnement scientifique, donc je suppose que la majorité des golfeurs MATL (AB) / Octave viennent de l'extérieur de CS.
Sanchises

4

M , 15 14 octets

²×3’
*3Ḥ‘÷Ç
Ç¡

Essayez-le en ligne!

Algorithme

Cela utilise des rationnels et la méthode de Newton. Plus précisément, pour l'entrée x , les premières x itérations avec la valeur de départ x sont appliquées.

Nous essayons de trouver une racine spécifique du polynôme p (t) = t³ - t - 1 . La méthode de Newton y parvient en prenant une valeur de départ t 0 - suffisamment proche de ρ - et en définissant récursivement une séquence par
t n + 1 = t n - p (t n ) / p '(t n ) .

Puisque p '(t) = 3t² -1 , on obtient
t n + 1 = t n - (t n ³ - t n - 1) / (3t n ² - 1) = (3t n ³ - t n - t n ³ + t n + 1) / (3t n ² - 1) = (2t n ³ + 1) / (3t n ² - 1) .

Notez que l'approximation initiale x s'aggrave progressivement à mesure que x augmente. Alors que la sortie pour x = 3 est légèrement moins précise que la sortie pour x = 2 , puisque la méthode de Newton converge de façon quadratique vers ρ , cela ne devrait pas être un problème pour les grandes valeurs de x .

Comment ça marche

Ç¡    Main link. Argument: x

Ç¡    Call the second helper link x times, which initial argument x.


*3Ḥ‘÷Ç  Second helper link. Argument: t

*3      Compute t³.
  Ḥ     Unhalve; yield 2t³.
   ‘    Increment; yield 2t³+1.
     Ç  Call the first helper link with argument t.
    ÷   Divide the left result by the right one.


²×3’    First helper link. Argument: t

²       Compute t².
 ×3     Compute 3t².
   ’    Decrement; yield 3t²-1.

Dommage que vous ne puissiez pas utiliser ... µ¡...
Erik the Outgolfer



1

Fusain , 28 octets

AIθθAθνW‹∕∕Xν³θθ⁺νθA⁺ν¹νI∕νθ

Essayez-le en ligne! Lien vers le mode verbeux. J'ai aussi apparemment foiré Divideet IntDivide: |
Utilise la même méthode que les réponses Python et JavaScript.


1

NewStack , 14 octets

¹Fᵢ{E2x³⁺÷3x²⁻

Panne:

¹                Add arbitrary number 1 to the stack.
 Fᵢ{             Define for loop with a user's input amount of itterations.
    E            Define new edit for element 0 (element 0 being the 1 added. earlier).
     2x³⁺÷3x²⁻   update x to equal (2x^3+1)/(3x^2-1). (x = element 0).

Comment ça marche:

La formule (2x 3 +1) / (3x 2 -1) provient de la simplification de la méthode de Newton pour l'équasion x 3 = x + 1. Vous pouvez le trouver ici . Répéter ce processus une infinité de fois converge vers le nombre plastique. Son taux de convergence est plutôt rapide à environ 2,6 décimales par itération.

INPUT ITERATION >> VALUE
0 >> 1
1 >> 1.5
2 >> 1.3478260869565217
3 >> 1.325200398950907
4 >> 1.3247181739990537
5 >> 1.3247179572447898
6 >> 1.324717957244746    <- 16 decimal precision in 6 iterations!
...
100 >> 1.324717957244746

Alternative à la séquence Padovan, 27 25 17 octets

¹Fᵢ{[ƨ2+ƨ3]ℲƤƨ/ƨ2

Panne:

¹                  Append first element of Padovan sequence.
 Fᵢ{       Ⅎ       Define for loop of user's input amount of iterations.
    [ƨ2+ƨ3]        Append sum second and third to last elements.
            Ƥƨ/ƨ2  Print ratio of last two elements.

-2 octets en choisissant une meilleure stratégie d'impression

-8 octets en choisissant une meilleure façon d'indexer la pile

Comment ça marche:

Au fur et à mesure que la séquence de Padovan se poursuit, le rapport des deux derniers éléments converge vers le nombre de plastique.

INPUT ITERATION >> VALUE
0 >> 1
1 >> 2
...
10 >> 1.3157894736842106
...
89 >> 1.324717957244746    <- 16 decimal precision in 89 iterations
...
100> > 1.324717957244746

0

Clojure, 46 octets

#(nth(iterate(fn[i](Math/pow(inc i)(/ 3)))1)%)

Utilise la formule itérée de racine cubique. C'est un peu plus intéressant mais plus long:

(def f #(apply comp(repeat %(fn[i](Math/pow(inc i)(/ 3))))))

((f 10)1)
1.3247179361449652

"Vous ne pouvez pas supposer que l'arithmétique à virgule flottante dans votre langue est arbitrairement précise, mais vous devez plutôt utiliser sa précision réelle (ce qui signifie que la sortie d'un nombre à virgule flottante ne sera possible que dans les langues où la précision des nombres à virgule flottante peut être contrôlé lors de l'exécution). »
Anders Kaseorg

Ooh, je ne l'ai pas remarqué, quelle déception. Et l'implémentation de la racine cubique avec BigDecimal semble assez délicate.
NikoNyrh

0

Javascript, 36 octets

f=(x,n=x)=>n**3/x/x<n+x?f(x,++n):n/x

Fonctionne de la même manière que la réponse python supérieure. Non console.logétait inclus car si vous exécutez f(x)dans la console, il sera enregistré automatiquement.

f=(x,n=x)=>n**3/x/x<n+x?f(x,++n):n/x
console.log(f(300))


0

> <> , 38 + 3 = 41 octets

11\n;
?!\}2,:01{::::}**-+0(?$-{+{1-:}

Attend que l'entrée soit présente sur la pile au démarrage du programme, donc +3 octets pour l' -vindicateur.

Essayez-le en ligne!

Effectue efficacement une recherche binaire pour affiner la valeur de sortie. L' xaugmentation augmente le nombre d'itérations à effectuer.

Edit: calcul légèrement refactorisé pour économiser 1 octet, version précédente:

11\n;
?!\}2,:0{::::}**$-1-0)?$-{+{1-:}


0

TI-BASIC, 21 octets

:Prompt X //Prompt for input, 3 bytes
:While X  //While X, 3 bytes
:³√(1+Y→Y //Calculate cube root of 1+Y and store to Y, 7 bytes
:DS<(X,0  //Decrement X and skip next command (which doesn't do anything), 5 bytes
:End      //End While loop, 2 bytes
:Y        //Display Y, 1 byte

Utilise cette formule récursive .

Fait intéressant, coder en dur le nombre et l'arrondir donne le même nombre d'octets:

TI-BASIC, 21 octets

:Prompt X    //Prompt for input, 3 bytes
:.5√(3       //Store √(3)/2 to Ans, 5 bytes
:Ansֿ¹cosh(3ֿ¹coshֿ¹(3Ans //Store the plastic number to Ans, 9 bytes
:round(Ans,X //Round the plastic number X decimal digits, 4 bytes

Utilise cette formule trigonométrique .


Je ne pense pas que vous puissiez utiliser les flotteurs de TI-BASIC ici:Your answer must work in a hypothetical variant of your language in which integers can be arbitrarily large, and memory (including stack) is unlimited. You may not assume that floating-point arithmetic in your language is arbitrarily accurate, but must instead use its actual accuracy (meaning that outputting a floating-point number is only going to be possible in languages where the accuracy of floating-point numbers can be controlled at runtime).
lirtosiast

0

C # , 317 octets

using m=System.Math;a=x=>{if(a==0)return "1/1";var d=a(x-1).Split('/');var b=int.Parse(d[0]);var c=int.Parse(d[1]);return string.Format("{0}/{1}",(2*m.Pow(b,3)+m.Pow(c,3)).ToString(new string('#',int.MaxValue.ToString().Length)),(3*m.Pow(b,2)*c-m.Pow(c,3)).ToString(new string('#',int.MaxValue.ToString().Length)));};

Il renvoie le résultat sous forme de fraction.

Explication

Il utilise la méthode de Newton avec x itérations pour trouver la racine du polynôme p ^ 3-p-1 = 0. La formule est x_n = 1- (f (x_ (n-1))) / (f '(x_ (n-1))), et x_0 est un point de départ.

La dérivée des polynômes est 3p ^ 2-1, et disons x_ (n-1) = b / c. Ensuite, en utilisant la formule ci-dessus, nous obtenons que x_n = (2 b ^ 3 + c ^ 3) / (3 b ^ 2 cc ^ 3). Disons également que nous partons de 1, cela se produira lorsque x = 2, car x> 1, et est un entier. Code identifié et commenté:

using System;
string PlasticNumber(int x)
{
    if (x == 2) 
        return "1/1";                 

//If x=2, we return our starting value, but we need to return it as a fraction

    var d = PlasticNumber(x - 1).Split('/');
    var b = System.Convert.ToInt32(d[0]);
    var c = int.Parse(d[1]);

//We parse the previous value of the fraction, and put it into two variables

    return string.Format("{0}/{1}", 
        (2 * Math.Pow(b, 3) + Math.Pow(c, 3))
        .ToString(new string('#', int.MaxValue.ToString().Length)),
        (3 * Math.Pow(b, 2) * c - Math.Pow(c, 3))
        .ToString(new string('#', int.MaxValue.ToString().Length)));

//We return the result as a fraction, but it's important not to return it in
  scientific notation, because that will cause issues in the parsing process 

}


0

Axiome, 96 octets

h(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);r:=solve(x^3-x=1,10.^-n);digits(j);rhs(r.1))

résultats

(31) -> [h(i) for i in 0..10]
   (31)
   [1.0, 1.3, 1.33, 1.325, 1.3247, 1.32472, 1.324718, 1.324718, 1.32471796,
    1.324717957, 1.3247179572]
                                                         Type: List Float

comment vous pouvez voir h (2) devrait être 1,32 et non 1,33, donc il y a une erreur dans les derniers chiffres

Ensuite, il y aurait celui de 110 octets

g(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);x:=sqrt(23./108);r:=(.5+x)^(1/3)+(.5-x)^(1/3);digits(j);r)

Il utilise la formule pour résoudre l'équation de grade III de type x ^ 3-3 * p * x-2 * q = 0 dans le cas q ^ 2-p ^ 3> = 0 qui est m = sqrt (q ^ 2- p ^ 3) et x = (q + m) ^ (1/3) + (qm) ^ (1/3)

Dans notre cas r ^ 3-r-1 = 0, cela peut être écrit comme r ^ 3-3 * (1/3) r-2 * (1/2) = 0 donc p = 1/3 q = 1/2 m = 1 / 4-1 / 27 = 23/108 x = (0,5 + m) ^ (1/3) + (0,5-m) ^ (1/3)

celui-ci qui utilise l'itération de Newton avec le point de départ r = 1

f(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);e:=10^-n;r:=1.;repeat(v:=(r^3-r-1)/(3*r^2-1);abs(v)<e=>break;r:=r-v);digits(j);r)

il change dans la fonction, valeur des chiffres pour obtenir un obj de n + 1 chiffres après le point flottant. À la fin, la valeur digits () est affectée à la valeur précédente.


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.