[modifié en mars 2015: passage à Python 3 + généralisation de la méthode de Héron d'Alexandrie]

Le module mathématique “normal” Python ('math') calcule en double précision du C, c'est à dire avec un nombre de chiffres significatifs limité (environ 17).

Or, certains calculs arithmétiques, exploitant la capacité de Python de faire les calculs sur des entiers de taille quelconque, butent contre cette limitation. Le problème est donc:

• comment obtenir la racine entière d'un nombre entier de taille quelconque sans jamais passer par les nombres décimaux?

Pour plus d'informations, voir par exemple:

• http://fr.wikipedia.org/wiki/Racine_carr%C3%A9e_enti%C3%A8re
• http://fr.wikipedia.org/wiki/Racine_carr%C3%A9e#Les_racines_carr.C3.A9es.2C_approximations_enti.C3.A8res
• etc…

On va voir ici les méthodes suivantes:

• la fameuse méthode de Héron d'Alexandrie pour calculer la racine carrée
• une généralisation de cette méthode pour calculer la racine kième
• une méthode de recherche par dichotomie pour calculer la racine kième

Référence (entre autres) pour la méthode: http://fr.wikipedia.org/wiki/M%C3%A9thode_de_H%C3%A9ron

C'est tout de même une méthode qui a environ 2000 ans, et qui est très efficace! Chapeau Héron!

Voilà le code proposé:

def lrac2(n):
    """Racine carrée entière d'un nombre entier n de taille quelconque
           (méthode de Heron d'Alexandrie).
       Génère un exception "ValueError" si n est négatif.
    """
    #  traitement des cas particuliers
    if n < 2:
        if n < 0:
            raise ValueError("Erreur: racine carrée d'un nb négatif")
        else:
            return n  # n = 0 ou 1
 
    # trouve une valeur approchée de la racine (important pour les grds nb)
    rac1, i = n, 1
    while rac1 != 0:
        rac1 >>= 1
        i += 1  # i = compteur du nb de positions binaires utilisées
    rac1 = 1 << (i >> 1)
 
    # calcule la racine en partant de la racine approchée rac1
    delta = n - 1
    while True:
        rac2 = (rac1 + n // rac1) >> 1
        if rac2 >= rac1 and delta <= 1:
            return rac1
        delta = abs(rac2 - rac1)  # on garde pour la prochaine boucle
        rac1 = rac2

Exemple d'utilisation: racine carrée d'un nombre de 100 chiffres:

n = 95530115674158268118807420816522758470211742812771200355432247162672847736704127934600588321797829111
print(lrac2(n))
309079464982968850936954612591482075156307515681951

Résultat obtenu en moins d'1/10000 de seconde: ce code est très rapide!

En fait, pour des entiers de grande taille (plusieurs centaines de chiffres), la rapidité de calcul dépend en grande partie de la méthode permettant d'évaluer une racine approchée (ici, l'initialisation de rac1). Pour ce calcul approché, on utilise les divisions et multiplications binaires par 2 qui sont rapides.

Avec cet algorithme, on arrive à des performances étonnantes: moins d'1/1000 de seconde pour calculer la racine carrée de nombres de 1000 chiffres…

J'ai appliqué l'algorithme de calcul ici:

http://fr.wikipedia.org/wiki/Algorithme_de_calcul_de_la_racine_n-i%C3%A8me

Voilà le code proposé:

def lrack(n, k=2):
    """Racine kième entière d'un nb entier n de taille quelconque
       Génère une exception  "ValueError" si n est négatif et k paire.
    """
 
    # initialisation du signe et traitement des  cas particuliers
    signe = +1
    if n < 2:
        if n < 0:
            if k % 2 == 0:
                raise ValueError("Erreur: racine paire d'un nombre négatif")
            else:
                signe, n = -1, abs(n)
        else:
            return n  # ici n = 0 ou 1
 
    # trouve une valeur approchée de la racine (important pour les grds nb)
    rac1, i = n, 0
    while rac1 > 0:
        rac1 >>= 1
        i += 1  # i = compteur du nb de positions binaires utilisées
    rac1 = 1 << (i // k)
 
    # calcul de la racine en partant de la racine approchée rac1
    delta = abs(n - 1)
    km1 = k - 1
    while True:
        rac2 = (km1 * rac1 + n // (rac1 ** km1)) // k
        if rac2 >= rac1 and delta <= 1:
            return signe * rac1
        delta = abs(rac2 - rac1)  # on garde pour la prochaine boucle
        rac1 = rac2

Pour ce calcul, il a fallu tenir compte:

• de k pour la racine kième
• du signe puisqu'on peut calculer ici la racine kième d'un nombre négatif si k est impair

En examinant l'algorithme, on voit que la méthode de Héron d'Alexandrie n'en est qu'un cas particulier avec k=2. Bien sûr, le calcul donne le même résultat que précédemment avec k=2, avec d'ailleurs un temps de calcul très proche.

Exemple d'application: racine 5ème d'un nombre de 100 chiffres:

n = 95530115674158268118807420816522758470211742812771200355432247162672847736704127934600588321797829111
print(lrack(n, 5)) # racine 5ème de n
157046427221351911140

Résultat obtenu en moins d'1/10000 seconde.

Voilà le code proposé. Il consiste en une simple fonction lrackd(n,k=2), n étant le nombre entier dont on veut obtenir la racine entière, et k la racine que l'on veut (2=carrée, 3=cubique, 4=4ème, 5=5ème, …). Sans la mention du 2ème argument, c'est la racine carrée qui est prise par défaut.

Cette fonction donne la racine entière r d'un nombre entier n. Ce qui veut dire que la vraie racine réelle (avec les éventuels chiffres après la virgule) se trouvera être >=r et <r+1.

Enfin, cette fonction tient compte d'un éventuel signe négatif de n, mais avec une restriction: si n est négatif et k pair, le calcul est évidemment impossible, et la fonction déclenchera une exception ValueError. Par contre, si k est impair, la racine d'un n négatif se fera et retournera une racine r également négative.

Pour des entiers de grande taille, une grande partie de la rapidité de l'algorithme repose sur la capacité à encadrer le calcul de la racine par 2 racines approchées (ici rac1 et rac2).

def lrackd(n, k=2):
    """racine entière kième d'un nombre entier n de taille quelconque
       recherche par dichotomie
    """
 
    # initialisation du signe et traitement des  cas particuliers
    signe = +1
    if n < 2:
        if n < 0:
            if k % 2 == 0:
                raise ValueError("Erreur: racine paire d'un nombre négatif")
            else:
                signe, n = -1, abs(n)
        else:
            return n  # ici n = 0 ou 1
 
    # trouve rac1 et rac2 qui encadrent de plus près la valeur cherchée de la racine
    rac1, i = 1, 1
    while i <= n:
        rac1 <<= 1
        i <<= k
    rac2 = rac1
    rac1 >>= 1
 
    # calcule par dichotomie la racine r kième de n qui est entre rac1 et rac2
    while rac1 != rac2:
        r = (rac1 + rac2) >> 1
        rn = r ** k
        if rn > n:
            rac2 = r
        else:
            rac1 = r + 1
    if n - rn < 0:
        r -= 1
 
    # retour de la racine avec le bon signe
    if signe > 0:
        return r
    return -r

Exemple d'application: calcul de la racine 5ème d'un nombre de 100 chiffres:

n = 95530115674158268118807420816522758470211742812771200355432247162672847736704127934600588321797829111
print(lrackd(n, 5)) # racine 5ème de n
157046427221351911140

Bien entendu, si par exemple vous prenez la racine entière 5ème ci-dessus et que vous calculiez sa puissance 5, vous ne retrouvez pas le nombre initial n: parce qu'on n'a pas les décimales, et que le nombre n n'était pas une puissance 5ème exacte. Par contre, vous pouvez vérifier cela:

n = 157046427221351911140**5  # ce qui donne 95530115674158268117011886873321123603202109596146187950666441653568720214191812971191238942582400000
print(lrackd(n,5))
157046427221351911140

On peut vérifier aussi que si le nombre n est un entier “normal” (pas long), on trouve la bonne valeur:

n = 9
print(lrackd(n)) 
3

Conséquence amusante: peut-on calculer avec ça la racine carrée normale de 2 ? Bien sûr! Il suffit d'ajouter un nombre pair de zéros et d'en retirer la moitié à la fin.

Par exemple, en ajoutant 50 zéros:

n = 2*10**50
 
r = lrack(n) 
# renvoie: 14142135623730950488016887
 
r2 = math.sqrt(n)  
# renvoie 1.41421356237e+025

On a bien trouvé tous les chiffres de la fonction normale, plus d'autres! Comme on a ajouté 50 zéros (exposant forcément pair pour k=2!), il faut bien entendu déplacer la virgule de 25 positions sur la gauche pour la mettre à la bonne place. Mais si vous vous contenter de diviser par 10E25: vous vous retrouvez en nombres flottants normaux et vous perdez les chiffres supplémentaires.

Vous voulez plus de chiffres significatifs? Facile: voilà la racine de 2 avec 5000 chiffres après la virgule.

n = 2*10**10000
print(lrack(n)) 

résultat obtenu en seulement 1/10 seconde (on ajoute le point décimal à la main, et on remet en une seule ligne):

1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727350
13846230912297024924836055850737212644121497099935831413222665927505592755799950501152782060571470109559
97160597027453459686201472851741864088919860955232923048430871432145083976260362799525140798968725339654
63318088296406206152583523950547457502877599617298355752203375318570113543746034084988471603868999706990
04815030544027790316454247823068492936918621580578463111596668713013015618568987237235288509264861249497
71542183342042856860601468247207714358548741556570696776537202264854470158588016207584749226572260020855
84466521458398893944370926591800311388246468157082630100594858704003186480342194897278290641045072636881
31373985525611732204024509122770022694112757362728049573810896750401836986836845072579936472906076299694
13804756548237289971803268024744206292691248590521810044598421505911202494413417285314781058036033710773
09182869314710171111683916581726889419758716582152128229518488472089694633862891562882765952635140542267
65323969461751129160240871551013515045538128756005263146801712740265396947024030051749531886292563138518
81634780015693691768818523786840522878376293892143006558695686859645951555016447245098368960368873231143
89415576651040883914292338113206052433629485317049915771756228549741438999188021762430965206564211827316
72625753959471725593463723863226148274262220867115583959992652117625269891754098815934864008345708518147
22318142040704265090565323333984364578657967965192672923998753666172159825788602633636178274959942194037
77753681426217738799194551397231274066898329989895386728822856378697749662519966583525776198939322845344
73569479496295216889148549253890475582883452609652409654288939453864662574492755638196441031697983306185
20193793849400571563337205480685405758679996701213722394758214263065851322174088323829472876173936474678
37431960001592188807347857617252211867490424977366929207311096369721608933708661156734585334833295254675
85164471075784860246360083444911481858765555428645512331421992631133251797060843655970435285641008791850
07603610091594656706768836055717400767569050961367194013249356052401859991050621081635977264313806054670
10293569971042425105781749531057255934984451126922780344913506637568747760283162829605532422426957534529
02883876844642917328277088831808702533985233812274999081237189254072647536785030482159180188616710897286
92292011975998807038185433325364602110822992792930728717807998880991767417741089830608003263118164279882
31171543638696617029999341616148786860180455055539869131151860103863753250045581860448040750241195184305
67453368361367459737442398855328517930896037389891517319587413442881784212502191695187559344438739618931
45499999061075870490902608835176362247497578588583680374579311573398020999866221869499225959132764236194
10592100328026149874566599688874067956167391859572888642473463585886864496822386006983352642799056283165
61391394255764906206518602164726303336297507569787060660685649816009271870929215313236828135698893709741
65044745909605374727965244770940992412387106144705439867436473384774548191008728862221495895295911878921
49179833981083788278153065562315810360648675873036014502273208829351341387227684176678436905294286984908
38455744579409598626074249954916802853077398938296036213353987532050919989360751390644449576845699347127
63645071632791547015977335486389394232572775400382602747856741725809514163071595978498180094435603793909
85590168272154034581581521004936662953448827107292396602321638238266612626830502572781169451035379371568
82336593229782319298606467978986409208560955814261436363100461559433255047449397593399912541953230093217
53044765339647066276116617535187546462096763455873861648801988484974792640450654448969100407942118169257
96857563784881498986416854994916357614484047021033989215342377037233353115645944389703653166721949049351
88290580630740134686264167247011065346349391640714628556798017793381442404526913706660977763878486623800
33923243704741153318725319060191659964553811578884138084332321053376746181217801429609283241136275254088
73729051294073394794330619439569367020794295158782283493219316664111301549594698378977674344435393377099
57134988407890850815892366070088658105470949790465722988880892461282816013133701029080290999745647849581
54561464871551639050241985790613109345878330620026220737247167668545549990499408571080992575992889323661
54382719550057816251330381531465779079268685008069844284791524242754410268057563215653220618857512251130
63937025362927161968251259192025216058701189596732244239267423734490764646727375347964598819149807931718
00242385545388603836831080077918246646275411744425001872777951816438345146346129902076334301796855438563
16677235183893366670422221109391449302879638128398893117313084300421255501854985065294556377660314612559
09104611384768282359592477228629042642736163264585443392877263860343149804896397363329754885925681149296
83612672589857383321643666348702347730261010613050729861153412994880877447311122954265275165366591173014
236062652

Mais voilà: comment être sûr que tous mes chiffres sont bons? Je n'ai pas trouvé sur le web de valeurs de racine de 2 qui dépassaient les 100 chiffres. Pourtant, c'est simple, et j'ai déjà donné la solution plus haut:

• r*r donne bien un résultat légèrement inférieur à 2: 10001 chiffres dont les 5000 premiers sont 1.9999….998 (avec n = carré parfait, r*r serait exactement égal à n)
• (r+1)*(r+1) donne bien un résultat légèrement supérieur à 2: 10001 chiffres dont les 5000 premiers sont 2.000…000 suivis d'une liste de chiffres non nuls.

En résumé, la racine carrée entière de n est correcte quand la condition suivante est satisfaite:

r*r <= n < (r+1)*(r+1)

De même pour la racine kième:

r**k <= n < (r+1)**k

Ce qu'on a fait pour la racine carrée de 2 peut se généraliser à une racine kième quelconque, mais le nombre de zéros qu'on ajoute doit être divisible par k.

Voici par exemple la racine cubique de 7 avec 80 chiffres après la virgule. On a donc ajouté 240 zéros au 7 initial, et il faudra en retirer 80 au résultat final (240//3=80):

n = 7*10**240
print(lrack(n, 3))

ce qui donne, après un déplacement à la main de la virgule sur 80 positions:

1.91293118277238910119911683954876028286243905034587576621064764044723427617923075

résultat obtenu en moins d'1/1000 de seconde.

Voilà comment, pour des valeurs n et k entières quelconques (et n éventuellement signé si k est pair), on peut vérifier que la fonction r=lrack(n, k) donne un résultat correct:

def okrac(r, n, k=2):
    """dit si r est la racine entière kième du nombre entier n 
    """
    if k % 2 == 0:
        if r < 0 or k < 0:
            return False
    else:
        if (n < 0 and r > 0) or (n > 0 and r < 0):
            return False
    r, n = abs(r), abs(n)
    if r ** k <= n and (r + 1) ** k > n:
        return True
    else:
        return False

Continuons à nous amuser: nous allons créer une fonction additionnelle permettant d'obtenir la racine réelle d'un nombre entier avec un nombre de décimal donné:

def frac(n, k=2, nbc=20):
    rch = str(lrack(n * 10 ** (nbc * k), k))
    pospt = len(rch) - nbc
    return '.'.join([rch[:pospt], rch[pospt:]])
 
# voilà la racine cubique de 5 avec 50 chiffres: 
print(frac(5, 3, 50))
1.70997594667669698935310887254386010986805511054305

Le résultat est bien sûr renvoyé sous forme de chaine de caractère à cause du point décimal. On pourrait aussi renvoyer un nombre tel que défini dans le module “decimal”.

Voilà un exemple de ce que cette fonction peut faire pour des nombres de 1 à 20:

Calcul des racines carrées décimales avec 50 chiffres après la virgule:

for x in xrange(1,21):
    print("%2d" % x, frac(x,2,50))
 
 1 1.00000000000000000000000000000000000000000000000000
 2 1.41421356237309504880168872420969807856967187537694
 3 1.73205080756887729352744634150587236694280525381038
 4 2.00000000000000000000000000000000000000000000000000
 5 2.23606797749978969640917366873127623544061835961152
 6 2.44948974278317809819728407470589139196594748065667
 7 2.64575131106459059050161575363926042571025918308245
 8 2.82842712474619009760337744841939615713934375075389
 9 3.00000000000000000000000000000000000000000000000000
10 3.16227766016837933199889354443271853371955513932521
11 3.31662479035539984911493273667068668392708854558935
12 3.46410161513775458705489268301174473388561050762076
13 3.60555127546398929311922126747049594625129657384524
14 3.74165738677394138558374873231654930175601980777872
15 3.87298334620741688517926539978239961083292170529159
16 4.00000000000000000000000000000000000000000000000000
17 4.12310562561766054982140985597407702514719922537362
18 4.24264068711928514640506617262909423570901562613084
19 4.35889894354067355223698198385961565913700392523244
20 4.47213595499957939281834733746255247088123671922305

Calcul des racines cubiques avec 50 chiffres après la virgule:

for x in xrange(1,21):
    print("%2d" % x, frac(x,3,50))
 
 1 1.00000000000000000000000000000000000000000000000000
 2 1.25992104989487316476721060727822835057025146470150
 3 1.44224957030740838232163831078010958839186925349935
 4 1.58740105196819947475170563927230826039149332789985
 5 1.70997594667669698935310887254386010986805511054305
 6 1.81712059283213965889121175632726050242821046314121
 7 1.91293118277238910119911683954876028286243905034587
 8 2.00000000000000000000000000000000000000000000000000
 9 2.08008382305190411453005682435788538633780534037326
10 2.15443469003188372175929356651935049525934494219210
11 2.22398009056931552116536337672215719651869912809692
12 2.28942848510666373561608442387935401783181384157586
13 2.35133468772075748950001633995691452691584198346217
14 2.41014226417522998612836966760327289535458128998086
15 2.46621207433047010149161132315458904273548448662805
16 2.51984209978974632953442121455645670114050292940301
17 2.57128159065823535545318720873972611642790163245469
18 2.62074139420889660714166128044199627023942764572363
19 2.66840164872194486733962737197083033509587856918310
20 2.71441761659490657151808946967948920480510776948909

Calcul des racines 5ième avec 50 chiffres après la virgule:

for x in xrange(1,21):
    print("%2d" % x, frac(x,5,50))
 
 1 1.00000000000000000000000000000000000000000000000000
 2 1.14869835499703500679862694677792758944385088909779
 3 1.24573093961551732596668033664030508093930999306877
 4 1.31950791077289425937400197122964013303346901319341
 5 1.37972966146121483239006346421601769285564987797760
 6 1.43096908110525550104522441314311690497264993966128
 7 1.47577316159455206927691669563224410654409361374020
 8 1.51571656651039808234725980130644523868128354297814
 9 1.55184557391535967427334513551669932326234629380966
10 1.58489319246111348520210137339150701326944213382503
11 1.61539426620217800150814788206383584541653520546929
12 1.64375182951722576230849793623097951738349258994547
13 1.67027765233481039480365289131271463129106884569004
14 1.69521820307243548154934358460776711529438056468409
15 1.71877192758747877701352145204440915713545891795175
16 1.74110112659224827827254003495949219795825084869600
17 1.76234034783231701386100225356486992808302928195816
18 1.78260245796600335549488747214008661063589569472799
19 1.80198312731714230518255395296189025894370970228005
20 1.82056420302608026437942105470546298493768742795884

Revenons maintenant à la fonction initiale lrack().

Si vous voulez vérifier que votre fonction donne bien le bon résultat, vous pouvez procéder comme suit:

from random import randint
while True:
    k = randint(2, 20)
    if k % 2 == 0:
        s = 1
    else:
        s = [-1, 1][randint(0, 1)]
    e = 10 ** randint(1, 50)
    n = s * randint(e, e * 10 - 1)
    rac = lrack(n, k)
    print("n=", n, "k=", k, "=> racine=", rac)
    if not okrac(rac, n, k):
        print("erreur")
        raise ValueError

Grâce au module random, ce code tire au hasard:

• le niveau de la racine k (2=carré, 3=cubique, etc…) de 2 à 20
• le signe positif ou négatif (positif seul si n est pair)
• le nombre de chiffres du nombre n dont on va calculer la racine
• le nombre n lui-même avec le bon nombre de chiffres

Ensuite, le calcul de la racine est faite, ainsi que le test de validité okrac().

Le calcul boucle indéfiniment, et ne s'arrête qu'à la 1ère erreur trouvée (s'il y en a une) ou avec Ctle-C. Vous pouvez donc laisser tourner pendant plusieurs heures, voire plusieurs jours, si nécessaire.

Voilà un exemple de sortie:

n= 75495734 k= 18 => racine= 2
n= -80962953866247211039394800262871750 k= 17 => racine= -113
n= 4891253697941566905308674563740 k= 4 => racine= 47027841
n= 48320171439282366839527268276313841988 k= 10 => racine= 5866
n= 28779456330615571989554676685839 k= 11 => racine= 724
n= 6825613759962 k= 15 => racine= 7
n= 715795763040540816210823765134136685 k= 12 => racine= 972
n= 1451040758 k= 20 => racine= 2
n= 90553084163348580 k= 14 => racine= 16
n= -97240360265942765704021091296670265 k= 7 => racine= -99601
n= 6615729409 k= 11 => racine= 7
n= 81819 k= 16 => racine= 2
n= 393297733166051962579054 k= 2 => racine= 627134541518
n= -63604085714835362844892630682339055540675047 k= 7 => racine= -1809842
n= -338002881675985173683343 k= 15 => racine= -37
n= 15040819 k= 14 => racine= 3
n= 4208005 k= 4 => racine= 45
n= 36225492918 k= 20 => racine= 3
n= 31334006275758284427290851387 k= 18 => racine= 38
n= 958616917940483554478054936796488650914 k= 17 => racine= 196
n= 262776679529 k= 15 => racine= 5

Pour vérifier que les puissances parfaites trouvent bien leur solutions (c'est à dire que si x=r**n au départ, on retrouve bien r par lrack(n,k)), on peut tester comme suit:

r = 7
k = 2
while True:
    n = r**k
    if lrack(n,k)==r:
        print(r, k, n)
    else:
        print(r, k, n, " <===== erreur!")
        break
    k += 1

Ce qui donne comme début de résultat:

7 2 49
7 3 343
7 4 2401
7 5 16807
7 6 117649
7 7 823543
7 8 5764801
7 9 40353607
7 10 282475249
7 11 1977326743
7 12 13841287201
7 13 96889010407
7 14 678223072849
7 15 4747561509943
7 16 33232930569601
7 17 232630513987207
7 18 1628413597910449
7 19 11398895185373143
7 20 79792266297612001
7 21 558545864083284007
7 22 3909821048582988049
7 23 27368747340080916343
7 24 191581231380566414401
7 25 1341068619663964900807
7 26 9387480337647754305649
7 27 65712362363534280139543
7 28 459986536544739960976801
7 29 3219905755813179726837607
7 30 22539340290692258087863249
7 31 157775382034845806615042743
7 32 1104427674243920646305299201
7 33 7730993719707444524137094407
7 34 54116956037952111668959660849
7 35 378818692265664781682717625943
7 36 2651730845859653471779023381601
7 37 18562115921017574302453163671207
7 38 129934811447123020117172145698449
7 39 909543680129861140820205019889143
7 40 6366805760909027985741435139224001
7 41 44567640326363195900190045974568007
7 42 311973482284542371301330321821976049
7 43 2183814375991796599109312252753832343
7 44 15286700631942576193765185769276826401
7 45 107006904423598033356356300384937784807
7 46 749048330965186233494494102694564493649
7 47 5243338316756303634461458718861951455543
7 48 36703368217294125441230211032033660188801
7 49 256923577521058878088611477224235621321607
7 50 1798465042647412146620280340569649349251249
7 51 12589255298531885026341962383987545444758743
7 52 88124787089723195184393736687912818113311201
7 53 616873509628062366290756156815389726793178407
7 54 4318114567396436564035293097707728087552248849
7 55 30226801971775055948247051683954096612865741943
7 56 211587613802425391637729361787678676290060193601
7 57 1481113296616977741464105532513750734030421355207
7 58 10367793076318844190248738727596255138212949486449
7 59 72574551534231909331741171093173785967490646405143
7 60 508021860739623365322188197652216501772434524836001
7 61 3556153025177363557255317383565515512407041673852007
7 62 24893071176241544900787221684958608586849291716964049
7 63 174251498233690814305510551794710260107945042018748343
7 64 1219760487635835700138573862562971820755615294131238401
7 65 8538323413450849900970017037940802745289307058918668807
7 66 59768263894155949306790119265585619217025149412430681649
7 67 418377847259091645147530834859099334519176045887014771543
7 68 2928644930813641516032715844013695341634232321209103400801
7 69 20500514515695490612229010908095867391439626248463723805607
7 70 143503601609868434285603076356671071740077383739246066639249
7 71 1004525211269079039999221534496697502180541686174722466474743
7 72 7031676478883553279994550741476882515263791803223057265323201
7 73 49221735352184872959961855190338177606846542622561400857262407
7 74 344552147465294110719732986332367243247925798357929806000836849
7 75 2411865032257058775038130904326570702735480588505508642005857943
7 76 16883055225799411425266916330285994919148364119538560494041005601
7 77 118181386580595879976868414312001964434038548836769923458287039207
7 78 827269706064171159838078900184013751038269841857389464208009274449
7 79 5790887942449198118866552301288096257267888893001726249456064921143
7 80 40536215597144386832065866109016673800875222251012083746192454448001
7 81 283753509180010707824461062763116716606126555757084586223347181136007
7 82 1986274564260074954771227439341817016242885890299592103563430267952049
7 83 13903921949820524683398592075392719113700201232097144724944011875664343
7 84 97327453648743672783790144527749033795901408624680013074608083129650401
7 85 681292175541205709486531011694243236571309860372760091522256581907552807
7 86 4769045228788439966405717081859702655999169022609320640655796073352869649
7 87 33383316601519079764840019573017918591994183158265244484590572513470087543
7 88 233683216210633558353880137011125430143959282107856711392134007594290612801
7 89 1635782513474434908477160959077878011007714974754996979744938053160034289607
7 90 11450477594321044359340126713545146077054004823284978858214566372120240027249
7 91 80153343160247310515380886994816022539378033762994852007501964604841680190743
7 92 561073402121731173607666208963712157775646236340963964052513752233891761335201
7 93 3927513814852118215253663462745985104429523654386747748367596265637242329346407
7 94 27492596703964827506775644239221895731006665580707234238573173859460696305424849
7 95 192448176927753792547429509674553270117046659064950639670012217016224874137973943
7 96 1347137238494276547832006567721872890819326613454654477690085519113574118965817601
7 97 9429960669459935834824045974053110235735286294182581343830598633795018832760723207
7 98 66009724686219550843768321818371771650147004059278069406814190436565131829325062449
7 99 462068072803536855906378252728602401551029028414946485847699333055955922805275437143
7 100 3234476509624757991344647769100216810857203198904625400933895331391691459636928060001

Cela veut dire que, par exemple, si on part de n=22539340290692258087863249 obtenu par 7**30, on retrouve bien exactement 7 en calculant la racine 30_ième avec la fonction: lrack(22539340290692258087863249, 30)

Et pour prendre un autre exemple, la racine 150ème de n = 5817092933824343165432524003391691164919859649719340532627567207607656859034356995566589707894210757866827613621721127496191249 redonne bien 7 avec lrack(n,150).

Amusez-vous bien!