Debat Languages Basics

Coolman · Message par **Coolman** » mar. 18/janv./2005 11:45

Dobro, c'est vrai, tu es un genie

et tout le monde sait qu'il ne faut pas contredire un genie sous peine de le voir peter un plomb, ce que je ne te souhaites pas, je vais donc te laisser penser ce que tu veux

*****************************

J'ai adapté le code pour purebasic, le resultas est ci-dessous :

Calcul sur les nombre entiers :

Blitzbasic Purebasic
Addition 74.0 798
soustraction 73.0 800
multiplication 74.0 845
division 723.0 1185

Calcul sur les nombre reels :

Addition 212.0 801
soustraction 211.0 800
multiplication 215.0 800
division 464.0 920

Bon, ce n'est pas etonnant, la version demo de pure ne permet pas de desactiver le mode debug, mais ce qui est bizarre, c'est que le temps de calcul est quasiment similaire sur les variables integer et float, c'est la premiere fois que je vois ca, en general j'utilise beaucoup les entiers avec le basic codés sur 2 octects pour accelerer tous les traitements, regardez par exemple la difference avec le calcul sous blitzbasic...

Je serais curieux de voir ce ca donne avec une version complete de pureb, si quelqu'un veut faire le test ?

Voici le code :

Code : Tout sélectionner

; ****************** Code PUREBASIC ******************************************
DefType.w Boucle,n,i,V1,V2
DefType.f CALC,FIN,DEB,res2,V22,V12

Temp$=""

OpenConsole() 
Boucle = 32000
GloBoucle = 1000
PrintN ("Boucle Calcul Deux Variables 32000")
PrintN ("Fois 1000 Fois De Suite")
;-------------------------------------------------------------------------------
;                    CALCUL SUR LES ENTIERS
;
;******  MODULE TEST  ********************************************************
PrintN ("")
PrintN ("")
PrintN ("CALCUL SUR DES NOMBRES ENTIERS")
PrintN ("")
res = 0: V1  = 250: V2 = 100
   DEB  = ElapsedMilliseconds() 
   For n  = 1 To GloBoucle
   For i  = 1 To Boucle
   res  = V1 + V2 
   Next
   Next
  FIN  = ElapsedMilliseconds()  
CALC  = (FIN  - DEB )
PrintN ("ADDITION       : "+Str(CALC))
;******  MODULE TEST  ********************************************************
res  = 0: V1 = 250: V2  = 100
   DEB  = ElapsedMilliseconds()  
   For n  = 1 To GloBoucle
   For i  = 1 To Boucle
   res  = V1 - V2 
   Next
   Next
   FIN  = ElapsedMilliseconds()  
CALC  = (FIN  - DEB )
PrintN ("SOUSTRACTION   : "+Str(CALC ))
;******  MODULE TEST  ********************************************************
res  = 0: V1 = 250: V2  = 100
   DEB  = ElapsedMilliseconds()  
   For n  = 1 To GloBoucle
   For i  = 1 To Boucle
   res  = V1 * V2 
   Next
   Next
   FIN  = ElapsedMilliseconds()  
CALC  = (FIN  - DEB )
PrintN ("MULTIPLICATION : "+Str(CALC ))
;******  MODULE TEST  ********************************************************
res  = 0: V1 = 250: V2  = 100
   DEB  = ElapsedMilliseconds()  
   For n  = 1 To GloBoucle
   For i  = 1 To Boucle
   res  = V2  / V1 
   Next
   Next
   FIN  = ElapsedMilliseconds()  
CALC  = (FIN  - DEB )
PrintN ("DIVISION       : "+Str(CALC ))
;-------------------------------------------------------------------------------
;                    CALCUL SUR LES REELS
PrintN ("")
PrintN ("")
PrintN ("CALCUL SUR DES NOMBRES REELS")
PrintN ("")
res2  = 0: V12 = 250: V22 = 100
   DEB  = ElapsedMilliseconds()  
   For n  = 1 To GloBoucle
   For i  = 1 To Boucle
   res2  = V12 + V22
   Next
   Next
   FIN  = ElapsedMilliseconds()  
CALC  = (FIN  - DEB )
PrintN ("ADDITION       : "+Str(CALC ))
;******  MODULE TEST  ********************************************************
res2  = 0: V12  = 250: V22  = 100
   DEB  = ElapsedMilliseconds()  
   For n  = 1 To GloBoucle
   For i  = 1 To Boucle
   res2  = V12  - V22 
   Next
   Next
   FIN  = ElapsedMilliseconds()  
CALC  = (FIN  - DEB )
PrintN ("SOUSTRACTION   : "+Str(CALC ))
;******  MODULE TEST  ********************************************************
res2  = 0: V12  = 250: V22  = 100
   DEB  = ElapsedMilliseconds()  
   For n  = 1 To GloBoucle
   For i  = 1 To Boucle
   res2  = V12  * V22 
   Next
   Next
   FIN  = ElapsedMilliseconds()  
CALC  = (FIN  - DEB )
PrintN ("MULTIPLICATION : "+Str(CALC ))
;******  MODULE TEST  ********************************************************
res2  = 0: V12  = 250: V22  = 100
   DEB  = ElapsedMilliseconds()  
   For n  = 1 To GloBoucle
   For i  = 1 To Boucle
   res2  = V22  / V12 
   Next
   Next
   FIN  = ElapsedMilliseconds()  
CALC  = (FIN  - DEB )
PrintN ("DIVISION       : "+Str(CALC ))
Input() 
CloseConsole() 
End

Le Soldat Inconnu

heu, tu n'as pas l'impression d'avoir un dépassement de capacité du format long signé ???

pour l'addition :
32000*100*1000 = 3 200 000 000 > 2 147 483 647
idem soustraction
pour la multiplication, n'est parlons même pas

je ne sais pas avec quoi tu as travaillé sur l'autre basic en type de variable mais ... si c'est pas du 64bits, ça a fait pareil

donc pas très explicite, ton test

Le Soldat Inconnu

voici un test qui compare l'addition de PB directement avec de l'ASM

j'ai exactement la même vitesse de calcul

(activer l'assembleur en ligne dans les propriété du code

Code : Tout sélectionner

#nb = 10000000
#nb2 = 100

Temps1 = ElapsedMilliseconds()

For nn = 1 To #nb2
  Long.l = 0
  For n = 1 To #nb
    Long + 7
  Next
Next

Temps2 = ElapsedMilliseconds()

For nn = 1 To #nb2
  Long.l = 0
  For n = 1 To #nb
    INC Long
  Next
Next

Temps3 = ElapsedMilliseconds()

MessageRequester("Test rapidité", "Solution 1 : " + Str(Temps2 - Temps1) + " ; Solution 2 : " + Str(Temps3 - Temps2) + Chr(10) + "Ratio = 1 / " + StrF((Temps2 - Temps1) / (Temps3 - Temps2)), 0)

Alors je vois pas bien comment on peut aller plus vite ?
surtout que pour pure, je fais "Valeur = Valeur + 5" et que en ASM, je fais la fonction incrément de 1.
j'ai déduis que l'un ou l'autre, on a le même temps processeur

j'ai pas testé pour les multiplication et division (je sais pas faire ces bêtes en asm)

Coolman · Message par **Coolman** » mar. 18/janv./2005 13:11

Le Soldat Inconnu a écrit :heu, tu n'as pas l'impression d'avoir un dépassement de capacité du format long signé ???

pour l'addition :
32000*100*1000 = 3 200 000 000 > 2 147 483 647
idem soustraction
pour la multiplication, n'est parlons même pas

je ne sais pas avec quoi tu as travaillé sur l'autre basic en type de variable mais ... si c'est pas du 64bits, ça a fait pareil

donc pas très explicite, ton test

Il ne s'agit que d'une boucle for - next, les variables res V1 et V2 sont initailisés a :

res=0
V1=250
V2=100

le calcul est effectué 32000 fois 1000 fois de suite, c'est le meme calcul :

addition : res=250 + 100

soustra : res=250 -100

multip : res=250 * 100

divis : res=250 / 100

Depassement ??? ou ca ???

Coolman · Message par **Coolman** » mar. 18/janv./2005 16:55

J'ai egallement adapté pour Ibasicpro, et blitzbasic apparait environ deux fois plus rapide, voici le code pour ibaspro :

Code : Tout sélectionner

DEF boucle:SWORD
DEF Globoucle:SWORD
DEF n:SWORD
DEF i:SWORD

DEF res:SWORD
DEF V1:SWORD
DEF V2:SWORD

DEF res2:FLOAT
DEF V12:FLOAT
DEF V22:FLOAT

DEF CALC:DOUBLE
DEF FIN:DOUBLE
DEF DEB:DOUBLE


boucle  = 32000
Globoucle  = 1000
OPENCONSOLE
Print "Boucle Calcul Deux Variables 32000"
Print "Fois 1000 Fois De Suite"
'-------------------------------------------------------------------------------
'                    CALCUL SUR LES ENTIERS
'
'******  MODULE TEST  ********************************************************
Print
Print
Print "CALCUL SUR DES NOMBRES ENTIERS"
Print
res  = 0: V1  = 250: V2  = 100
	  DEB  =  MILLISECS()
	  For n  = 1 To Globoucle 
	  For i  = 1 To boucle 
			res  = V1  + V2 
	  Next i
	  Next n
	  FIN  =  MILLISECS()
CALC  = (FIN  - DEB )
Print "ADDITION       : "+Str$(CALC )
'******  MODULE TEST  ********************************************************
res  = 0: V1  = 250: V2  = 100
	  DEB  =  MILLISECS()
	  For n  = 1 To Globoucle 
	  For i  = 1 To boucle 
			res  = V1  - V2 
	  Next i
	  Next n
	  FIN  =  MILLISECS()
CALC  = (FIN  - DEB )
Print "SOUSTRACTION   : "+Str$(CALC )
'******  MODULE TEST  ********************************************************
res  = 0: V1  = 250: V2  = 100
	  DEB  =  MILLISECS()
	  For n  = 1 To Globoucle 
	  For i  = 1 To boucle 
			res  = V1  * V2 
	  Next i
	  Next n
	  FIN  =  MILLISECS()
CALC  = (FIN  - DEB )
Print "MULTIPLICATION : "+Str$(CALC )
'******  MODULE TEST  ********************************************************
res  = 0: V1  = 250: V2  = 100
	  DEB  =  MILLISECS()
	  For n  = 1 To Globoucle 
	  For i  = 1 To boucle 
			res  = V1  / V2 
	  Next i
	  Next n
	  FIN  =  MILLISECS()
CALC  = (FIN  - DEB )
Print "DIVISION       : "+Str$(CALC )
'-------------------------------------------------------------------------------
'                    CALCUL SUR LES REELS
Print
Print
Print "CALCUL SUR DES NOMBRES REELS"
Print
res2  = 0: V12  = 250: V22  = 100
	  DEB  =  MILLISECS()
	  For n  = 1 To Globoucle 
	  For i  = 1 To boucle 
			res2  = V12  + V22 
	  Next i
	  Next n
	  FIN  =  MILLISECS()
CALC  = (FIN  - DEB )
Print "ADDITION       : "+Str$(CALC )
'******  MODULE TEST  ********************************************************
res2  = 0: V12  = 250: V22  = 100
	  DEB  =  MILLISECS()
	  For n  = 1 To Globoucle 
	  For i  = 1 To boucle 
			res2  = V12  - V22 
	  Next i
	  Next n
	  FIN  =  MILLISECS()
CALC  = (FIN  - DEB )
Print "SOUSTRACTION   : "+Str$(CALC )
'******  MODULE TEST  ********************************************************
res2  = 0: V12  = 250: V22  = 100
	  DEB  =  MILLISECS()
	  For n  = 1 To Globoucle 
	  For i  = 1 To boucle 
			res2  = V12  * V22 
	  Next i
	  Next n
	  FIN  =  MILLISECS()
CALC  = (FIN  - DEB )
Print "MULTIPLICATION : "+Str$(CALC )


'******  MODULE TEST  ********************************************************
res2  = 0: V12  = 250: V22  = 100
	  DEB  =  MILLISECS()
	  For n  = 1 To Globoucle 
	  For i  = 1 To boucle 
			res2  = V12  / V22 
	  Next i
	  Next n
	  FIN  =  MILLISECS()
CALC  = (FIN  - DEB )
Print "DIVISION       : "+Str$(CALC )
DO: UNTIL INKEY$ <> ""
CLOSECONSOLE
END

Le Soldat Inconnu

ah oui, j'ai mal vu

nico · Message par **nico** » mar. 18/janv./2005 20:09

Voilà tes résultats pour Ibasic Pro:

Blitzbasic IbasicPro
Addition 74.0 - 270
soustraction 73.0 - 260
multiplication 74.0 - 331
division 723.0 - 1442

Calcul sur les nombre reels :

Addition 212.0 - 701
soustraction 211.0 - 631
multiplication 215.0 - 671
division 464.0 - 1262

hardy · Message par **hardy** » mar. 18/janv./2005 22:36

Je n'ai que PB, alors pour comparer...
Avec un Pentium M 1.4GHz:

entiers:
141
125
172
922

floats
156
188
172
734

Quant à la différence entre "réels" (disons plutôt décimaux) et entiers, il est normal qu'il y en ait peu : la seule manip en plus est l'addition des exposants, ce qui représente un temps faible face au temps mis pour le calcul (addition,...)
Il est bizarre qu'il y ait de telles différences dans certains langages.
un processeur ne fait que des calculs sur les entiers, en fait.

L'ordi travaille en base 2, pas en base 10. Mais pour l'ordinateur, un décimal est un couple d'entiers : par exemple, 987.5432 et représenté sous la forme (9875432,-4). le -4, c'est pour 10^-4.
Quand tu demande 1.2345*987.5432, pour lui, c'est "(1234,-3)*(9875432,-4)" = (1234*9875432,-3-4)
Le seul calcul en plus, c'est -3-4. Pas grand chose, face au produit!

comtois · Message par **comtois** » mar. 18/janv./2005 22:53

sur un pentium 2,6
j'ai
78
78
108
704

et

78
62
80
452

mais bon , c'est bien de faire plusieurs milliers de fois la boucle, mais il faudrait aussi faire une moyenne des temps , parce que si je lance le test plusieurs fois , je n'ai jamais le même résultat.
l'ordre de grandeur ne change pas , quoique parfois l"écart peut être important plus de 20% .
par exemple au premier lancement j'ai 78 pour l'addition des entiers , en lançant le code une deuxième fois , je n'ai plus que 60 .

hardy · Message par **hardy** » mar. 18/janv./2005 23:03

Pour éliminer les irrégularités, augmente les répétitions pour obtenir des temps de quelques secondes.
Puis évidemment, faut voir ce qui tourne en même temps.
Mais ça ne doit pas trop influer : le prog prend à peu près tout le CPU.

comtois · Message par **comtois** » mar. 18/janv./2005 23:06

ouaip mais bon , là je crois que si avec tout ça Coolman n'arrive toujours pas à se décider , il ne le fera jamais

hardy · Message par **hardy** » mar. 18/janv./2005 23:10

Certes, il a l'air quelque peu indécis.

Puis quand même, vu le prix de la licence PB, c'est quand même pas un gros investissement !

Backup · Message par **Backup** » mar. 18/janv./2005 23:45

Faudrait pas exagérer mon bon Dobro : la rapidité, ça compte!
S'il s'agit de 3-4%, effectivement, c'est négligeable.
Mais si c'est 50, 100%,etc... ça n'a rien de négligeable!!
Quand on fait des programmes travaillant sur de grandes bases de données, ou/et faisant plein de calculs tout de même...
A part pour de "petites" appli. pas méchantes, c'est plus la règle que l'exception. (qu'il s'agisse de jeux, d'antivirus,...)
Va t'amuser à faire des trucs de ce genre avec des langages interprétés, et tu vas sentir ta douleur.
Quant à la différence de rapidité entre les divers basics, je ne pense pas qu'il y en ait de grosses en programmant "bien".
Les manières de compiler doivent fortement se ressembler.

ne sortez pas mes propos du context e et du suget de ce post SVP !

ici Coolman veut se faire une opignon des basic les plus utilisés

tous sont des basic compillé ! (les interpretes ne font pas partie de la mem categorie et donc , ne sont pas comparable avec des basic compillé ! )

je ne dit pas que la vitesse ne compte pas !!

je dit que comparer Purebasic, Ibasic, DARK basic , et Blitz basic
est une connerie !!

car ces language sont tous tres performant , et que les difference de quelque milliseconde qui les separe , n'ont pas de reel importance pour la majorité d'entre nous !!

ce qui est important , c'est les fonctions dont ces basic disposes
car les fonctions (commandes ) des basics c'est leur vocabulaire !
et plus le vocabulaire est riche mieux c'est !!

lorsqu'on a comme basic des languages qui propose tous des
interets dans un domaine ou dans un autre
la seul chose qui compte c'est ce qu'on veut en faire !

comparer la vitesse dont les difference se chiffre en quelques centieme de seconde est debile !

dans ce cas Coolman n'a qu' a acheter un assembleur et voila plus de probleme a la con !

sans compter qu'il existe des basic dont la specialité est les grand nombre d'autres la 3D , d'autres les base de donnée , d'autre les application bureautique !
bref on s'en sort pas la !!

faut savoir arreter les gars !!
si Coolman veux un avis des differents basics , il lui vaux mieux demander dans chaque forum des different language Basic concerné, l'avis des utilisateur respectif !!

c'est de la masturbation intellectuel , c'est comme les gars qui conaissent par coeur le rapport poid puissance des voitures de sport !!
le gars qui est au pedale , tous ce qu'il demande c'est que lorsqu'il appuis sur l'accelerateur , la voiture pousse !

je le redit pour moi c'est idiot !!

maintenant si ça vous amuse de vous "toucher" les meninge la dessus !

ok! ok! continuez , j'ai rien dit !
juste voulu donner mon avis , puisque c'est un "Debat" , que je pensait ouvert a tous !

pardon donc de vous avoir embeté dans vos cogitations !

hardy · Message par **hardy** » mar. 18/janv./2005 23:49

Oh la la...
C'est qu'il s'énerve notre Dobro!

Allez, une camomille, et au lit.

Coolman · Message par **Coolman** » mer. 19/janv./2005 12:16

Merci Nico, ca confirme assez mes resultas, mais pour ce qui en est de purebasic ?

Merci egallement a hardy, ca confirme egallement ce que j'ai lu sur les Pentium M qui sont a frequence moindre beaucoup plus performant que les pentiums classiques grace a leur cache plus important...

Pour comptois, tu as fait le test avec purebasic ? avec blitzbasic, j'ai fait le test plusieurs fois de suite, j'ai des ecarts mais jamais de 20 %, au contraire les resultas sont constant avec des petites variations, pour purebasic je ne sais pas...

*** Pour éliminer les irrégularités, augmente les répétitions pour obtenir des temps de quelques secondes. Puis évidemment, faut voir ce qui tourne en même temps. Mais ça ne doit pas trop influer : le prog prend à peu près tout le CPU.

En effet hardy, perso, j'ai un systeme clean avec tres peu de programme activé sous win98se et winxp pro, cela dit il n'y a pas dans la boucle de temporisation, donc les resultas peuvent varier mais pas de beaucoup...

*** ouaip mais bon , là je crois que si avec tout ça Coolman n'arrive toujours pas à se décider , il ne le fera jamais Smile

*** Certes, il a l'air quelque peu indécis.
Puis quand même, vu le prix de la licence PB, c'est quand même pas un gros investissement !

Vu ces resultas

, vous avouerez quand meme qu'il y'a de quoi hesiter, et puis quoi qu'en en dise, il ne s'agit pas de petites differences, je vois sur le meme ordinateur des ecarts tres importants, pourtant le code est tres simple...

hardy, ce n'est pas une question de prix, si je te dis combien j'ai acheté windev par exemple, tu va etre etonné mais en meme temps, ca n'a rien a voir, je l'ai rentabilisé au bout de 6 mois...
En fait comme je l'ai deja dit, je souhaite aborder la 3d en amateur, je cherche pour cela un language accessible et rapide sans prise de tete, non je ne me prend pas pour carmack sinon je ne serais pas ici, non je ne vais pas faire de la physique quantique, non je ne suis pas un genie, non je ne suis pas un savant de science fiction...

dobro, tu devrais te calmer, si je me rappelle bien, c'est toi le premier qui a dit que ce forum etait ouvert, pourtant, tes propos te contredisent, en plus tu n'apportes rien de concret dans ce debat sauf un evident manque de respect... Autre chose, je pense comprendre tres bien le francais et pourtant je n'arrive pas a suivre ton raisonnement, il est vrai que je suis plus logique qu'emotif...

Perso, grace a quelques intervenant, je me suis fait une idee du language que je vais acheter, ce sera soit purebasic soit blitzmax la version windows doit sortir bientot, je vais donc attendre encore un peu...

Maintenant, je vous vous poser une question, le sujet a l'air d'interesser pas mal de monde, voulez vous que je continue ce debat ou alors si ca commence a emmerder quelques uns, j'arrete...