For i = 2 To NB
result = a + b
aff = aff & i & ") " & result & vbCrLf
a = b
b = result
Next i
MsgBox aff
End Sub
'************************************************************************************
Pour rappel, dans la suite de Fibonacci chaque nombre (a l'exeption des 2
premiers) est le résultat de la somme des 2 nombres qui le précède.
For i = 2 To NB result = a + b aff = aff & i & ") " & result & vbCrLf a = b b = result Next i
MsgBox aff
End Sub
Hello,
on pourrait juste faire un commentaire sur l'emploi du type double qui peut sembler curieux dans la mesure ou la suite de Fibonacci est définie pour des entiers et pas des réels.
On utilise ici le type double parce que son range de valeurs est plus grand mais le plus naturel aurait sans doute été de définir a, b et résults comme des long.
-- Jean-marc
"RCR" <RCR@RCR.com> wrote in message
news:%23lTRFxslGHA.1552@TK2MSFTNGP04.phx.gbl...
Hello,
Si ça intéresse quelqu'un voila un petit exercice pour faire comprendre
l'utilisation des variable à des débutants.
'***********************************************************************************
Sub Fibo()
Dim a As Double
Dim b As Double
Dim result As Double
Dim NB As Integer
Dim aff As String
For i = 2 To NB
result = a + b
aff = aff & i & ") " & result & vbCrLf
a = b
b = result
Next i
MsgBox aff
End Sub
Hello,
on pourrait juste faire un commentaire sur l'emploi du type double
qui peut sembler curieux dans la mesure ou la suite de Fibonacci est définie
pour des entiers et pas des réels.
On utilise ici le type double parce que son range de valeurs est plus grand
mais le plus naturel aurait sans doute été de définir a, b et résults comme
des long.
For i = 2 To NB result = a + b aff = aff & i & ") " & result & vbCrLf a = b b = result Next i
MsgBox aff
End Sub
Hello,
on pourrait juste faire un commentaire sur l'emploi du type double qui peut sembler curieux dans la mesure ou la suite de Fibonacci est définie pour des entiers et pas des réels.
On utilise ici le type double parce que son range de valeurs est plus grand mais le plus naturel aurait sans doute été de définir a, b et résults comme des long.
-- Jean-marc
bayosky
Notre ami jm tapota :
On utilise ici le type double parce que son range de valeurs est plus grand mais le plus naturel aurait sans doute été de définir a, b et résults comme des long.
Bonjour,
pour manipuler de très gros entiers mieux vaut choisir un autre format que long ( c'est absurde méssétinsi )
avec 28 chiffres à droite du séparateur décimal : +/- 7,9228162514264337593543950335 ;
le plus petit nombre différent de zéro est +/- 0,000 000 000 000 000 000 000 000 000 1 soit 10 puissance - 28 ...
on peut donc travailler avec de gros entiers en conservant un excellente précision pour différencier un entier d'un non entier proche pour savoir si un quotient est exact, etc ... ----------------------------------------------
HB
Notre ami jm tapota :
On utilise ici le type double parce que son range de valeurs est
plus
grand mais le plus naturel aurait sans doute été de définir a, b et
résults comme des long.
Bonjour,
pour manipuler de très gros entiers
mieux vaut choisir un autre format que long
( c'est absurde méssétinsi )
avec 28 chiffres à droite du séparateur décimal :
+/- 7,9228162514264337593543950335 ;
le plus petit nombre différent de zéro est
+/- 0,000 000 000 000 000 000 000 000 000 1
soit 10 puissance - 28 ...
on peut donc travailler avec de gros entiers en conservant un
excellente précision
pour différencier un entier d'un non entier proche
pour savoir si un quotient est exact,
etc ...
----------------------------------------------
On utilise ici le type double parce que son range de valeurs est plus grand mais le plus naturel aurait sans doute été de définir a, b et résults comme des long.
Bonjour,
pour manipuler de très gros entiers mieux vaut choisir un autre format que long ( c'est absurde méssétinsi )
avec 28 chiffres à droite du séparateur décimal : +/- 7,9228162514264337593543950335 ;
le plus petit nombre différent de zéro est +/- 0,000 000 000 000 000 000 000 000 000 1 soit 10 puissance - 28 ...
on peut donc travailler avec de gros entiers en conservant un excellente précision pour différencier un entier d'un non entier proche pour savoir si un quotient est exact, etc ... ----------------------------------------------
HB
jean-marc
"bayosky" a écrit dans le message de news:
Notre ami jm tapota :
> On utilise ici le type double parce que son range de valeurs est > plus > grand mais le plus naturel aurait sans doute été de définir a, b et > résults comme des long.
Bonjour,
pour manipuler de très gros entiers mieux vaut choisir un autre format que long ( c'est absurde méssétinsi )
avec 28 chiffres à droite du séparateur décimal : +/- 7,9228162514264337593543950335 ;
le plus petit nombre différent de zéro est +/- 0,000 000 000 000 000 000 000 000 000 1 soit 10 puissance - 28 ...
on peut donc travailler avec de gros entiers en conservant un excellente précision pour différencier un entier d'un non entier proche pour savoir si un quotient est exact, etc ...
Hello,
c'est vrai que decimal et currency ont l'avantage de pouvoir manipuler de grands nombres. Je ne les emploie cependant jamais car ils ne sont pas "portables", c'est à dire que si j'écris un bout de code qui fait usage de ces types, je ne pourrais sans doute pas le porter tel quel dans un autre langage qui lui ne supporte pas ce type. D'autre part, les opérations sur ces types sont très lentes (ce qui n'est pas forcément un problème pour faire de la compta, mais beaucoup plus pour faire des maths).
Mais c'est clair, ils ont les avantages que tu expliques et si on a pas de contraintes de portabilité/vitesse, ça peut être très utile :-)
-- Jean-marc Tester mon serveur (VB6) => http://myjmnhome.dyndns.org "There are only 10 kind of people those who understand binary and those who don't." mailto: remove '_no_spam_' ;
"bayosky" <bidonus@pasla.ici> a écrit dans le message de
news:O1nXF1wlGHA.508@TK2MSFTNGP03.phx.gbl...
Notre ami jm tapota :
> On utilise ici le type double parce que son range de valeurs est
> plus
> grand mais le plus naturel aurait sans doute été de définir a, b et
> résults comme des long.
Bonjour,
pour manipuler de très gros entiers
mieux vaut choisir un autre format que long
( c'est absurde méssétinsi )
avec 28 chiffres à droite du séparateur décimal :
+/- 7,9228162514264337593543950335 ;
le plus petit nombre différent de zéro est
+/- 0,000 000 000 000 000 000 000 000 000 1
soit 10 puissance - 28 ...
on peut donc travailler avec de gros entiers en conservant un
excellente précision
pour différencier un entier d'un non entier proche
pour savoir si un quotient est exact,
etc ...
Hello,
c'est vrai que decimal et currency ont l'avantage de pouvoir
manipuler de grands nombres. Je ne les emploie cependant jamais
car ils ne sont pas "portables", c'est à dire que si j'écris
un bout de code qui fait usage de ces types, je ne pourrais
sans doute pas le porter tel quel dans un autre langage qui lui ne
supporte pas ce type.
D'autre part, les opérations sur ces types sont très lentes (ce qui
n'est pas forcément un problème pour faire de la compta, mais
beaucoup plus pour faire des maths).
Mais c'est clair, ils ont les avantages que tu expliques et si on
a pas de contraintes de portabilité/vitesse, ça peut être très
utile :-)
--
Jean-marc
Tester mon serveur (VB6) => http://myjmnhome.dyndns.org
"There are only 10 kind of people
those who understand binary and those who don't."
mailto: remove '_no_spam_' ; _no_spam_jean_marc_n2@yahoo.fr
> On utilise ici le type double parce que son range de valeurs est > plus > grand mais le plus naturel aurait sans doute été de définir a, b et > résults comme des long.
Bonjour,
pour manipuler de très gros entiers mieux vaut choisir un autre format que long ( c'est absurde méssétinsi )
avec 28 chiffres à droite du séparateur décimal : +/- 7,9228162514264337593543950335 ;
le plus petit nombre différent de zéro est +/- 0,000 000 000 000 000 000 000 000 000 1 soit 10 puissance - 28 ...
on peut donc travailler avec de gros entiers en conservant un excellente précision pour différencier un entier d'un non entier proche pour savoir si un quotient est exact, etc ...
Hello,
c'est vrai que decimal et currency ont l'avantage de pouvoir manipuler de grands nombres. Je ne les emploie cependant jamais car ils ne sont pas "portables", c'est à dire que si j'écris un bout de code qui fait usage de ces types, je ne pourrais sans doute pas le porter tel quel dans un autre langage qui lui ne supporte pas ce type. D'autre part, les opérations sur ces types sont très lentes (ce qui n'est pas forcément un problème pour faire de la compta, mais beaucoup plus pour faire des maths).
Mais c'est clair, ils ont les avantages que tu expliques et si on a pas de contraintes de portabilité/vitesse, ça peut être très utile :-)
-- Jean-marc Tester mon serveur (VB6) => http://myjmnhome.dyndns.org "There are only 10 kind of people those who understand binary and those who don't." mailto: remove '_no_spam_' ;
bayosky
Notre ami jean-marc tapota :
D'autre part, les opérations sur ces types sont très lentes (ce qui n'est pas forcément un problème pour faire de la compta, mais beaucoup plus pour faire des maths).
Certes... c'est une notion relative. pour traiter les gros entier, avec puissance, mieux vaut installer MuPAD qui peut communiquer via DDE avec d'autres exe... On dispose alors d'un moteur de calcul formel capable de travailler avec 10000 chiffres si on veut :o)
Ceci étant, j'ai fait un xla pour Excel qui contient , entre autre, lun fonction de décomposition en facteur premier. ( type decimal pour avoir de gros arguments)
J'ai testé sur des cas pathologiques (produit de deux gros premiers voisins) et, a ma grande surprise; même sur mon vieux W98 avec un Pentium à 300 Mhz, ça va nettement plus vite que la TI92 qui possède cette fonction en ROM ( donc optimisée) ... Donc ...
A+
Notre ami jean-marc tapota :
D'autre part, les opérations sur ces types sont très lentes (ce qui
n'est pas forcément un problème pour faire de la compta, mais
beaucoup plus pour faire des maths).
Certes... c'est une notion relative. pour traiter les gros entier,
avec puissance, mieux vaut installer MuPAD qui peut communiquer via
DDE avec d'autres exe... On dispose alors d'un moteur de calcul formel
capable de travailler avec 10000 chiffres si on veut :o)
Ceci étant, j'ai fait un xla pour Excel qui contient , entre autre,
lun fonction de décomposition en facteur premier. ( type decimal pour
avoir de gros arguments)
J'ai testé sur des cas pathologiques (produit de deux gros premiers
voisins) et, a ma grande surprise; même sur mon vieux W98 avec un
Pentium à 300 Mhz, ça va nettement plus vite que la TI92 qui possède
cette fonction en ROM ( donc optimisée) ... Donc ...
D'autre part, les opérations sur ces types sont très lentes (ce qui n'est pas forcément un problème pour faire de la compta, mais beaucoup plus pour faire des maths).
Certes... c'est une notion relative. pour traiter les gros entier, avec puissance, mieux vaut installer MuPAD qui peut communiquer via DDE avec d'autres exe... On dispose alors d'un moteur de calcul formel capable de travailler avec 10000 chiffres si on veut :o)
Ceci étant, j'ai fait un xla pour Excel qui contient , entre autre, lun fonction de décomposition en facteur premier. ( type decimal pour avoir de gros arguments)
J'ai testé sur des cas pathologiques (produit de deux gros premiers voisins) et, a ma grande surprise; même sur mon vieux W98 avec un Pentium à 300 Mhz, ça va nettement plus vite que la TI92 qui possède cette fonction en ROM ( donc optimisée) ... Donc ...
A+
RCR
Re à tous,
Je fais un grand Mea-culpa sur cette énorme erreur vous avez effectivement tous raison de vous interrogé sur le type de données et je vous remercie tous sur la remarquable qualité de vos remarque détailler qui vont certainement en aider plus d'un. Merci d'avoir compris les vrais buts d'internet. A+ tout le monde.
"RCR" a écrit dans le message de news: %
Hello, Si ça intéresse quelqu'un voila un petit exercice pour faire comprendre l'utilisation des variable à des débutants.
'*********************************************************************************** Sub Fibo()
Dim a As Double Dim b As Double Dim result As Double Dim NB As Integer Dim aff As String
For i = 2 To NB result = a + b aff = aff & i & ") " & result & vbCrLf a = b b = result Next i
MsgBox aff
End Sub '************************************************************************************ Pour rappel, dans la suite de Fibonacci chaque nombre (a l'exeption des 2 premiers) est le résultat de la somme des 2 nombres qui le précède.
Je fais un grand Mea-culpa sur cette énorme erreur vous avez effectivement
tous raison de vous interrogé sur le type de données et je vous remercie
tous sur la remarquable qualité de vos remarque détailler qui vont
certainement en aider plus d'un. Merci d'avoir compris les vrais buts d'internet.
A+ tout le monde.
"RCR" <RCR@RCR.com> a écrit dans le message de news:
%23lTRFxslGHA.1552@TK2MSFTNGP04.phx.gbl...
Hello,
Si ça intéresse quelqu'un voila un petit exercice pour faire comprendre
l'utilisation des variable à des débutants.
'***********************************************************************************
Sub Fibo()
Dim a As Double
Dim b As Double
Dim result As Double
Dim NB As Integer
Dim aff As String
For i = 2 To NB
result = a + b
aff = aff & i & ") " & result & vbCrLf
a = b
b = result
Next i
MsgBox aff
End Sub
'************************************************************************************
Pour rappel, dans la suite de Fibonacci chaque nombre (a l'exeption des 2
premiers) est le résultat de la somme des 2 nombres qui le précède.
Je fais un grand Mea-culpa sur cette énorme erreur vous avez effectivement tous raison de vous interrogé sur le type de données et je vous remercie tous sur la remarquable qualité de vos remarque détailler qui vont certainement en aider plus d'un. Merci d'avoir compris les vrais buts d'internet. A+ tout le monde.
"RCR" a écrit dans le message de news: %
Hello, Si ça intéresse quelqu'un voila un petit exercice pour faire comprendre l'utilisation des variable à des débutants.
'*********************************************************************************** Sub Fibo()
Dim a As Double Dim b As Double Dim result As Double Dim NB As Integer Dim aff As String
For i = 2 To NB result = a + b aff = aff & i & ") " & result & vbCrLf a = b b = result Next i
MsgBox aff
End Sub '************************************************************************************ Pour rappel, dans la suite de Fibonacci chaque nombre (a l'exeption des 2 premiers) est le résultat de la somme des 2 nombres qui le précède.
