J'ai trouvé l'idée, j'sais pas faire, au secour les matheux

[Kwai chang caine]

[SPH]

Meme un nombre converti en chaine prend plus de place que le nombre (pas en apparence ok mais au niveau octets utilisés)

[Huitbit]

'alut la compagnie !
J'ai pas trop le temps en ce moment mais il y a un truc tout bête(pas besoin de grosse théorie ) avec les logarithmes (dont parle djes ) :

Dans les exemples, je note logarithime à base n de x, logn(x) et ln le logarithme népérien(ou naturel) (ln sur la calculatrice).

Un log connu est celui à base 10, en fait log10(x)=ln(x)/ln(10)
Exemple(à essayer avec la calculatrice)
(a) log10(45677)=4.6596976....
(b) ln(45677)=10.72935
(c) ln(10)=2.3025....
(b)/(c)=(a)

Ben ça marche avec n'importe quelle base :
En base 2
log2(x)=ln(x)/ln(2)
Cette fonction log2(x) (logarithme à base 2) et l'inverse de 2^x.
2^56=7.205759...10^16
log2(7.205759...10^16)=56

KCC a écrit :

Si 15^12 = 129746337890625
et si je ne connais que 129746337890625
Comment fais-je pour trouver 15 et 12 ou bien deux autres chiffres qui donnent le même resultat.

Imaginons A^B=C (A=15 ; B=12 et C=1297.......)
En jouant avec les log, logA(C)=B
En fait pour C connu, il faut chercher des entiers A et B tels que
ln(C)/ln(A)=B

Une boucle sur A devrait suffire(attention ln(0) n'est pas défini et ln(1)=0 !!!! =>A doit commencer à 2), ensuite il faut montrer que B est entier!
Tout dépend des limites que tu souhaites pour A,B et C
Bien sûr le choix de C est capital pour avoir A et B entiers!

Ce n'est qu'une piste mais...
J'espère que les logarithmes te seront plus familliers....
...c'était juste pour faire avancer le schmilblick

Hasta la vista !

PS : attention aux confusions... dans PB, Log correspond au ln des mathématiques!

Syntaxe
Resultat.f = Log(Nombre.f)
Description
Renvoie le logarithme naturel du nombre.

[Kwai chang caine]

Merci pour l'info HUIT BIT

D'essayer de faire avancer l'affaire à propos de ces racines de $£*%"?!:! jusqu'a present et bien souvent, je n'avais en reponse qu'une autre question et ceci meme sur les forums de math

Je vais essayer de digérer ce que tu as écrit et je te tiendrais au courant par ce POST

Encore merci

[Kwai chang caine]

Bon apres plusieurs jour de cassage de tronche et grace au coup de main de huit bit et d'un morceau de code de DRI et de la recherche sur le terre net, j'suis déja arrivé à RELATIVEMENT comprendre ça.
Décidément, j'suis pas fait pour les maths
Et pourtant c'est pas que j'aimerais pas, mais bon......
Ca va paraitre banal à vous tous, mais pour moi, c'est déja noir de boulot

Code : Tout sélectionner

A = 15
B = 23

Debug "A = " + Str(A)
Debug "B = " + Str(B)
Debug ""

Debug "******************************************************************************************************"
Debug "                           LOGARITHMES RETROUVER LE PARAMETRE B"      
Debug "******************************************************************************************************"
Debug ""

; Si A^B = C Alors B = Log(C) / Log(A)

C.f = Pow(A, B) 

B = Log(C) / Log(A)

Debug "Si A^B = C      Alors     B = Log(C) / Log(A)"
Debug "-------------------------------------------------------------------"
Debug " "
Debug "C = Pow(A, B) = Pow(" + Str(A) + ", " + Str(B) + ") = " + Str(C)
Debug " "
Debug "B = Log(C) / Log(A) = Log(" + Str(C) + ") / Log(" + Str(A) + ") = " + Str(B) 
Debug ""

Debug "******************************************************************************************************"
Debug "                              EQUIVALENCE PRODUIT / SOMME DES LOG"
Debug "******************************************************************************************************"
Debug ""
Debug "Le logarithme du produit de deux nombres est egal à la somme des deux logarithmes de chacun de ces nombres"
Debug ""


; C = Log(AB) = Log(A) + Log(B) 

Procedure.f Exp(x.f) 
  Protected i.l 
  !NewCW equ p.v_i+0 
  !OldCW equ p.v_i+2 
  
  ;charge x sans s'occuper du signe 
  !FLD dword [p.v_x] 
  !FABS 
  
  ;n = x / Log(2) 
  !FLDLN2 
  !FDIVR st0, st1 
  
  ;récupère le CW 
  !FNSTCW word [NewCW] 
  !FNSTCW word [OldCW] 
  
  ;crée le CW pour arrondi par défaut 
  !AND   word [NewCW], $F3FF 
  !OR    word [NewCW], $0400 
  !FLDCW word [NewCW] 
  
  ;n = Floor(n) 
  !FRNDINT 
  
  ;restore le CW 
  !FLDCW word [OldCW] 
  
  ;u = x - n * Log(2) 
  !FXCH 
  !FLD st1 ;charge n 
  !FLDLN2 
  !FMULP 
  !FSUBP 
  
  ;m = Exp(u) 
  !FLD1 ;m 
  !FLD1 ;t 
  !MOV  dword [p.v_i], 1 
  
  exp_loop: 
  ;tant que t > 0 
  !FLDZ 
  !FCOMP 
  !FNSTSW ax 
  !TEST   ah, $40 
  !JNE    l_exp_end_loop 
  
  ;t * u / i 
  !FMUL  st0, st2 
  !FIDIV dword [p.v_i] 
  
  ;i + 1 
  !INC   dword [p.v_i] 
  
  ;m + t 
  !FADD  st1, st0 
  
  !JMP l_exp_loop 
  exp_end_loop: 
  
  !FSTP st0 ;retire t 
  !FSTP st1 ;retire u 
  !FSCALE   ;r = m * Pow(2, n) 
  !FSTP st1 ;retire n 
  
  ;si x négatif 
  !TEST dword [p.v_x], $80000000 
  !JE   l_exp_end 
  
  ;r = 1.0 / r 
  !FLD1 
  !FDIVRP 
  
  exp_end: 
  
  !ADD esp, 4 
  !RET 4 
EndProcedure 

Debug "C = Log(AB) = Log(A) + Log(B)" 
Debug "------------------------------------------------"
Debug " "
Debug "C = Log(A * B) = Log(" + Str(A) + " * " + Str(B) + ") = Log(" + Str(A * B) + ") = " + StrF(Log(A * B))
Debug " "
Debug "C = Log(A) + Log(B) = Log(" + Str(A) + ") + Log(" + Str(B) + ") = " + StrF(Log(A) + Log(B))
Debug ""

Debug "******************************************************************************************************"
Debug "                                         EXPONENTIELLES DES LOGS"             
Debug "******************************************************************************************************"
Debug ""
Debug "L'exponentielle est la fonction inverse du logarithme neperien d'un produit de deux nombres"
Debug ""

; Exp(Log(A * B)) = A * B

Debug "Exp( Log( A * B ) ) = A * B         et        Exp( Log(A) + Log(B) ) = A * B"
Debug "----------------------------------------------------------------------------------------------------------"
Debug ""
Debug "A * B = " + Str(A * B) 
Debug "Exp( Log(A) + Log(B) ) = Exp( Log(" + Str(A) + ") + Log(" + Str(B) + ") ) = " + StrF(Exp(Log(A) + Log(B)))
Debug "Exp( Log(A * B) ) = Exp( Log(" + Str(A) + " * " + Str(B) + " ) = " + StrF(Exp(Log(A * B)))
Debug ""
Debug "Ou bien :"
Debug ""
Debug "A * B = " + Str(A * B)
Debug "Log(A * B) = " + StrF(Log(A * B))
Debug "Exp(Log(A * B)) = " + StrF(Exp(Log(A * B)))

J'arrive à décomposer en facteur de nombre premier mon grand nombre, comme me l'a conseillé DJES et aussi le forum de math.

Bon ça c'est fait, mais j'ai encore pas trop fait le lien entre tout ça et mon besoin de retrouver les deux nombres de départ de ma puissance

Code : Tout sélectionner

Si A^B = C comment retrouver A et B en ne connaissant que C

Bon je continue, si "quinquin" vois une erreur, ou peux encore faire avancer le schmilblick, guy lux est preneur

[Huitbit]

Un petit code pour illustrer mes propos!
Comme tu peux le voir je me limite à 8^8, en effet entre le monde merveilleux des maths et celui de l'informatique, il y a la précision !(augmente la valeur de x dans le code et observe la différence "c-a^b" elle est parfois différente de 0)
Il faut être super vigilant avec le type des variables!
Les "float" c'est pas suffisant !

L'erreur vient peut-être aussi de ma mauvaise utilisation du type des variables, puisqu'en fait, je fais un peu au pif


Exemple, dans certains cas on va trouver 11,999999999999 alors qu'en théorie on devrait trouver 12 , ce qui entraîne une différence c-a^b non nulle

A propos de ça, pourquoi dans PB il n'y a pas de vrai fonction "arrondi"?
Parce que round () ou rien du tout, c'est la même chose!
Aide pb :!

Resultat.f = Round(11.5, 0) ; Renvoie 11
Resultat.f = Round(11.5, 1) ; Renvoie 12

En fait c'est le codeur qui fait l'arrondi
Autant utiliser int() !

Code : Tout sélectionner

x=8
tirage.d=Pow(Random(x),Random(x)) 
While tirage <1000 
  tirage=Pow(Random(x),Random(x)) 
Wend 
c.d=tirage 
Debug "c = "+StrD(c) 
a.d=1 
b.d=0 
While a<x+1 
  a=a+1 
  b=Int(Log(c)/Log(a)) 
  If c-Pow(a,b)<0.01 
    Debug "****************" 
    Debug "solution possible :" 
    Debug "a="+StrD(a)+"    b="+StrD(b)+"     c-a^b="+StrD(c-Pow(a,b)) 
    Debug "****************" 
  Else 
    Debug "a="+StrD(a)+"    b="+StrD(b)+"     c-a^b="+StrD(c-Pow(a,b)) 
  EndIf 
Wend 

Hasta la vista!

[comtois]

A propos de ça, pourquoi dans PB il n'y a pas de vrai fonction "arrondi"?
Parce que round () ou rien du tout, c'est la même chose!
Aide pb :

Resultat.f = Round(11.5, 0) ; Renvoie 11
Resultat.f = Round(11.5, 1) ; Renvoie 12

En fait c'est le codeur qui fait l'arrondi
Autant utiliser int() !

Depuis la 4.20 ce n'est plus le codeur qui fait l'arrondi

Code : Tout sélectionner

Debug Round(11.4999,#PB_Round_Nearest)
Debug Round(11.5000,#PB_Round_Nearest)
Debug Round(11.5001,#PB_Round_Nearest)

[Huitbit]

Super!!!

[Kwai chang caine]

@COMTOIS

Depuis la 4.20 ce n'est plus le codeur qui fait l'arrondi

Il est trop fort ce FRED, Y pense presque à tout
Par contre, je ne sais pas si ça fait ça chez vous, mais ça plante PB v4.10 de temps en temps ce genre de code
Je l'ai pourtant réinstallé et c'est KIF.
Il est peut etre comme moi, il aime pas les maths
Alors que la 4.20 nickel, bizarre non

@HUIT BIT
Merci de ton explication.
Oui j'avais remarqué l'imprecision.
Et encore tu va rire depuis le debut je prenais que des STR().
Alors la, la louche en deviens un instrument de precision

Puis je me suis apperçu que y'existait STRF() et compagnie.
C'est pas parfais mais beaucoup mieux.

Bon comme vous n'avez rien dit sur mon "devoir" de math, je suppose que "j'm'ai" pas trop trompé.
Je vais donc continuer dans cette voie, pour tenter de retrouver mon A et B en partant de la décomposition primaire du résultat de leur puissance

[Kwai chang caine]

Truc de ouf !!!!!!!!!!!
Je viens de découvrir que l'on peux faire des opérations directes sur les strings en 4.20
Est-ce normal ?

Par contre ça plante chez moi en v4.10
Est-ce normal aussi ?

Code : Tout sélectionner

Procedure TestEgaliter(a.s, b.s)
 
 If a = b
  Debug "Deux nombres égaux"
 ElseIf a > b 
  Debug "A supérieur à B"
 ElseIf a < b 
  Debug "A inférieur à B"
 EndIf 
 
EndProcedure

A.s = "127373873735746873487843783783738743738738773738737343435"
B.s = "127373873735746873487843783783738743738738773738737343435"

TestEgaliter(A, B)

A = "127373873735746873487843783783738743738738773738737343434"
B = "127373873735746873487843783783738743738738773738737343435"

TestEgaliter(A, B)

A = "127373873735746873487843783783738743738738773738737343435"
B = "127373873735746873487843783783738743738738773738737343434"

TestEgaliter(A, B)

[Kwai chang caine]

Demi joie
ça marche, mais seulement si les deux "phrases nombre" sont de la même longueur
Preuve en est :

Code : Tout sélectionner

Procedure TestEgaliter(a.s, b.s)
 
 If a = b
  Debug "Deux nombres égaux"
 ElseIf a > b 
  Debug "A supérieur à B"
 ElseIf a < b 
  Debug "A inférieur à B"
 EndIf 
 
EndProcedure

A.s = "40"
B.s = "40"

TestEgaliter(A, B)

A.s = "4"
B.s = "60"

TestEgaliter(A, B)

A.s = "4"
B.s = "30"

TestEgaliter(A, B)