Discussion :

[myflash]

comment faire 10.56 exposant 2.34 avec seulement les 4 opérations de base + - / x ? je dois faire une fonction power ( 10.56, 2.34 ) qui retourne 248.52699493621999158

[Stellar7]

Avec seulement les 4 opérations de base ?
Je crains que ce ne soit parti pour être un peu compliqué, car il ne va alors te rester que le développement limité en série de Taylor…

Bon code ! (et bon courage)

[myflash]

J'ai besoin de calculler des puissance avec des decimal d'une precision parfaite depassant 18 chiffre apres et avant la virgule.

Connaisser vous BigDecimal ? BigDecimal est un projet qui gerre un nombre decimal de precision illimiter (seul limite est la quantite de memoire de l'appareil). j'ai tester avec des fonction power ( double , double ) fournis avec le language, mais on a pas de precision des decimal, quand c'est calculler par le processeur.

Dans le fond je veux cree une fonction Power ( BigDecimal, BigDecimal ). les autre fonction comme log et autre doivent commencer par pouvoir faire un power. ya un power dans BigInteger mais pas dans BigDecimal.

[Flodelarab]

Bonjour

Question amusante.

Tu veux mobiliser toute la mémoire pour une précision maximale ? Mais alors, si j'ai besoin d'une autre variable, toute la mémoire est déjà prise par la première variable ? Donc, plus je crée de variables, plus je perds en précision ?

Tu es juste en train de découvrir que l'infini vis-à-vis de la précision est le même infini que celui vis-à-vis du maximum; en tout cas, un infini de même nature. Et de la même façon qu'il faut fixer un nombre de bits pour les nombre entiers, ce qui fixe ton amplitude maximale, il va falloir fixer un nombre de bits pour ton nombre décimal, ce qui fixera ta précision maximale.

Au fait, les calculatrices sont bidons en calcul. La seule raison pour laquelle ça marche, c'est qu'on se moque de la précision. Désolé pour la douche froide.

[WhiteCrow]

bonjour,
il y a des logiciels prévus pour ça, en opensource et gratuit on peut citer sage math.
il y a également des bibliothèques dédiées aux calculs en flottant à précision arbitraire, toujours en opensource et gratuit on pourra citer GNU MPFR.
on trouve aisément une liste de bibliothèques comme sur wikipedia.

[Canvas]

Bonsoir,

Pour faire ce calcul avec les 4 opérations de base, il est possible de ramener celui-ci à des calculs de racine carré et racine 5ième par la méthode de Newton.
On commence par calculer la quantité A = 10.56^117 et ensuite les différentes racines.

[myflash]

Bonjour

Question amusante.

Tu veux mobiliser toute la mémoire pour une précision maximale ? Mais alors, si j'ai besoin d'une autre variable, toute la mémoire est déjà prise par la première variable ? Donc, plus je crée de variables, plus je perds en précision ?

Tu es juste en train de découvrir que l'infini vis-à-vis de la précision est le même infini que celui vis-à-vis du maximum; en tout cas, un infini de même nature. Et de la même façon qu'il faut fixer un nombre de bits pour les nombre entiers, ce qui fixe ton amplitude maximale, il va falloir fixer un nombre de bits pour ton nombre décimal, ce qui fixera ta précision maximale.

Au fait, les calculatrices sont bidons en calcul. La seule raison pour laquelle ça marche, c'est qu'on se moque de la précision. Désolé pour la douche froide.

lollll je sais ca. une precision qui prend tout la memoire donner des million de decimal hehehehe j'ai juste besoin de envirront max 30, si j'arrondis a 31 ca me donne une precision de 30, il vas juste garder 30 en memoire. si je comprend bien mais utiliser les float ou double normal des language de programmation ils disent quon a une precision de genre 1e-4932 ... pas vrai pentout je fait 1225.345 - 1220 pis ca me donne 5.344999999999999970. je comprend que ca fait seullement une difference de 0.00000000000000003, mais moi pour une precision de 1e-4932 je m'attend a avoir une diference 1x 1e-4932 seullement pas 1x 1e-4.

mon projet a besoin d'une diference de 0 a une precision de 1e-30

BigDecimal me donne ca, mais il a pas les fonction log et power, seullement + - / x ou power avec des valeur entiere.

[myflash]

Bonsoir,

Pour faire ce calcul avec les 4 opérations de base, il est possible de ramener celui-ci à des calculs de racine carré et racine 5ième par la méthode de Newton.
On commence par calculer la quantité A = 10.56^117 et ensuite les différentes racines.

j'ai pas droit au racine... rien ... juste + - / x pis =

je vais faire des while pour aprocher la reponse jusqua un certain nombre de decimal maximum que je passe en parametre... ca vas bien pour des valeur entiere, mais les decimal oufff a part un racine avec 1/base je sais pas comment faire ca avec les + - / x

10 ^ 2 c'est simple c'est 10 x 10 meme 10.56 c'est 10.56 x 10.56 ... mais 10^2.32 c'est quoi on multiplis 10 par lui meme 2 fois mais le .32 ?!?! on peux pas multiplier 10 .32 fois par lui meme !!!!

[Guesset]

Bonjour,

Canvas a donné les relations de récurrence des deux suites qui convergent vers la racine carrée et la racine 5e.

La convergence est d'autant plus rapide que l'on commence avec une valeur pas trop éloignée de la valeur cible.

Une technique est de prendre la demi somme de 2ⁿ + x/2ⁿ quand x/2ⁿ devient inférieur à 2ⁿ. Un simple boucle fait le job : for(int _2n=1, double y=x; _2n < y; y /= 2, _2n *= 2);.

Une formule similaire est possible pour la racine cinquième (1/2 devient 1/5 et _2n devient _16n comme piste ).

Salutations

[Flodelarab]

j'ai pas droit au racine

Là, tu exagères. Il existe un algorithme, ressemblant à celui de la division euclidienne apprise à l'école primaire, qui donne la racine d'un nombre. Elle n'utilise donc que les 4 opérations de base. Renseigne-toi. On enseignait cette méthode au lycée avant l'arrivée des calculatrices.

[myflash]

Là, tu exagères. Il existe un algorithme, ressemblant à celui de la division euclidienne apprise à l'école primaire, qui donne la racine d'un nombre. Elle n'utilise donc que les 4 opérations de base. Renseigne-toi. On enseignait cette méthode au lycée avant l'arrivée des calculatrices.

du coup c'est en quelque sorte ce que je cherche, mais je ne ke trouve pas.. je veux programmer la fonction racine ou bien exposant qui utilise une technique similaire a cella avec seullement des + - / x quelque boucle et if je sais pas quoi mais aucune opération exposant ou racine fait par les fonctions qui vient avec le language... seullement les + - / x

imagine que faut que tu fait "10.56" exposant "2.32" mais avec des nombre dans des chaine de caractère que tu ne peux pas transformer en floating point... tu dois faire l'opération caractère par caractère et sauvegardé le résultat dans une chaine de caractères... a la limite mene les + - / et x sont des if mais ca il sont deja fait donc on peut les utiliser...

[Guesset]

Bonjour,
La solution proposée par Flodelarab marche très bien. On remplace les digits par les bits et comme les multiplicateurs ne sont que 0 ou 1, il n'y a pas d'opérations lourdes. C'est quand même une opération très binaire qui se prédispose plutôt à du code assembleur. Il y a par ailleurs des décalages qui deviennent des divisions/multiplications par 2 si les décalages sont exclus. Je ne sais pas si existe un équivalent en puissance 1/5.

Code PASCAL :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// Racine carré entière d'un entier____________________________________________________________ARITH
function iSqrt(i: integer): integer; assembler; nostackframe;
asm                          // ecx := i
   mov   edx, ecx            // i -> edx
   cmp   edx, 0
   jge   @iRoot_POSITIF
   neg   edx
@iRoot_POSITIF:
   xor   r8d, r8d            // 0 -> BX (Reste)
   xor   eax, eax            // 0 -> AX (Résultat)
//...........................Partie entière de la racine
   mov   ecx, 16             // Compteur de boucle
@iRoot_BOUCLE:
   shl   edx, 1              // Les 2 bits de poids fort de
   rcl   r8d, 1              // edx (i) deviennent les 2 bits
   shl   edx, 1              // de poids faible de r8d (reste).
   rcl   r8d, 1
   shl   eax, 2              // Reste > 4 * Résultat ?
   cmp   r8d, eax
   jg    @iRoot_UN
@iRoot_ZERO:
   shr   eax, 1              // Résultat := 2*Résultat
   jmp   @iRoot_FIN_BOUCLE
@iRoot_UN:
   sub   r8d, eax            // Reste := Reste-(4*Résultat+1)
   dec   r8d
   shr   eax, 1              // Résultat := 2*Résultat + 1
   inc   eax
@iRoot_FIN_BOUCLE:
   Loop  @iRoot_BOUCLE
   cmp   r8d, eax            // Arrondi
   jle   @iRoot_END
   inc   eax
@iRoot_END:
end;

A titre indicatif, je l'avais écrit parce j'avais besoin de la racine entière d'un entier et que ça me gênait de passer par des flottants. Pourtant malgré les conversions le calcul avec des flottants reste plus rapide.

Reprenons l'algorithme de Canvas pour un exemple comme 120.
Bien sûr on sait qu'une amorce de 10 ou 11 sera bonne mais faisons comme si on ne le savait pas.
Cherchons un bon germe avec la méthode proposée.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
120 > 1
 60  >  2
 30  >  4
 15  >  8
 7.5 < 16 => (7.5+16)/2 = 11.75

Appliquons l'algorithme classique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
u0 = 11.75
u1 = (11.75 + 120/11.75)/2 = 10.98138298
u2 = (u1 + 120/u1)/2 = 10.954484
u3 = (u2 + 120/u2)/2 = 10.95445115
u4 = (u3 + 120/u3)/2 = 10.95445115 // That's all !

Salutations