Debat Languages Basics

Coolman · Message par **Coolman** » dim. 16/janv./2005 14:09

Denis a écrit :Je veux bien faire des tests mais je ne recherche pas un prog pour mon job, alors je ne veux pas passer de temps à chercher la version que l'auteur voudrait bien s'il en a envie nous passer pour qu'on lui donne ensuite des dollars. Il faudra aussi remplir un formulaire avec le numéro de sécu, son tour de taille, le montant du salaire, si on est marié ou non, si on trompe sa femme... (heu, je m'égare )

Soit on peut tester une version même limitée soit on se tourne vers d'autres langages; ça en dit simplement long sur leur vision des choses.

Ca n'a rien contre toi Coolman.

Je suis tout a fait d'accord

, moi aussi je n'aime pas remplir des formulaires pour essayer un programme, reste que la curiosité est parfois plus forte. cela dit je vous rassure si vous commencez a douter, pour le moment et apres avoir visite le forum officiel anglais ainsi que quelques autres, purebasic est pour moi le meilleur (meilleur rapport qualite/prix), c'est d'ailleurs pour cette raison que je continues a visiter et intervenir sur votre forum

Anonyme2 · Message par **Anonyme2** » dim. 16/janv./2005 14:16

Du code du code !!!

Coolman · Message par **Coolman** » dim. 16/janv./2005 15:01

Bientot Bientot

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

Tiens, puisqu'on me demande du code, j'ai fait ca tres rapidement avec quickbasic, pour pure il faudra l'adapter, les commandes ont leurs equivalents (mais ca ne fonctionne pas avec la version demo, toujours cette satané limitation sur des fonctions pourtant pas essentielles, c'est pour ca que je l'ai fait en quickb) :

TIMER par apparement GetTickCount_()

Pour les variables, voici le typage sous quickbasic :

si la var est suivie de :

% entier
& entier long
! reel simple precisions
# reel double precisions

Pour le reste, la fonction USING1 qui formatte simplement le delai pour l'affichage (ca pourrait etre chiant a adapter, donc il suffit de remplacer PRINT USING1$(CALC#) par print CALC#)...

L'ideal, ce serait d'adapter ce code pour les differents compilateurs basic purebasic, blitzbasic, ibasic pro et faire le test sur la meme machine pour voir les differences...

Voici le code tres simple (ca va tres vite sur un P4, vous pouvez augmenter la var Globoucle% si c'est trop rapide pour vous) :

[/b]

Code : Tout sélectionner


boucle% = 32000
Globoucle% = 1000
PRINT " Boucle Calcul Deux Variables 32000 Fois, 1000 Fois De Suite"
'-------------------------------------------------------------------------------
'                    CALCUL SUR LES ENTIERS
'
'******  MODULE TEST  ********************************************************
PRINT
PRINT
PRINT "CALCUL SUR DES NOMBRES ENTIERS"
PRINT
PRINT "ADDITION       : ";
res% = 0: V1% = 250: V2% = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res% = V1% + V2%
	  NEXT i%
	  NEXT n%
FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "SOUSTRACTION   : ";
res% = 0: V1% = 250: V2% = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res% = V1% - V2%
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "MULTIPLICATION : ";
res% = 0: V1% = 250: V2% = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res% = V1% * V2%
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "DIVISION       : ";
res% = 0: V1% = 250: V2% = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res% = V2% / V1%
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'-------------------------------------------------------------------------------
'                    CALCUL SUR LES ENTIERS LONGS
PRINT
PRINT
PRINT "CALCUL SUR DES NOMBRES ENTIERS LONGS"
PRINT
'******  MODULE TEST  ********************************************************
PRINT "ADDITION       : ";
res& = 0: V1& = 250: V2& = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res& = V1& + V2&
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "SOUSTRACTION   : ";
res& = 0: V1& = 250: V2& = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res& = V1& - V2&
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "MULTIPLICATION : ";
res& = 0: V1& = 250: V2& = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res& = V1& * V2&
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "DIVISION       : ";
res& = 0: V1& = 250: V2& = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res& = V2& / V1&
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'-------------------------------------------------------------------------------
'                    CALCUL SUR LES REELS SIMPLES PRECISIONS
PRINT
PRINT
PRINT "CALCUL SUR DES NOMBRES REELS SIMPLES PRECISIONS"
PRINT
PRINT "ADDITION       : ";
res! = 0: V1! = 250: V2! = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res! = V1! + V2!
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "SOUSTRACTION   : ";
res! = 0: V1! = 250: V2! = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res! = V1! - V2!
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "MULTIPLICATION : ";
res! = 0: V1! = 250: V2! = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res! = V1! * V2!
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "DIVISION       : ";
res! = 0: V1! = 250: V2! = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res! = V2! / V1!
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'-------------------------------------------------------------------------------
'                    CALCUL SUR LES REELS DOUBLES PRECISIONS
PRINT
PRINT
PRINT "CALCUL SUR DES NOMBRES REELS DOUBLES PRECISIONS"
PRINT
PRINT "ADDITION       : ";
res# = 0: V1# = 250: V2# = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res# = V1# + V2#
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "SOUSTRACTION   : ";
res# = 0: V1# = 250: V2# = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res# = V1# - V2#
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "MULTIPLICATION : ";
res# = 0: V1# = 250: V2# = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res# = V1# * V2#
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
'******  MODULE TEST  ********************************************************
PRINT "DIVISION       : ";
res# = 0: V1# = 250: V2# = 100
	  DEB# = TIMER
	  FOR n% = 1 TO Globoucle%
	  FOR i% = 1 TO boucle%
			res# = V2# / V1#
	  NEXT i%
	  NEXT n%
	  FIN# = TIMER
CALC# = (FIN# - DEB#)
PRINT USING1$(CALC#)
END

FUNCTION USING1$ (res#)
DROIT$ = SPACE$(2): GAUCH$ = SPACE$(2): sss$ = LTRIM$(STR$(res#))
   IF res# = 0 THEN USING1$ = "00:00:00": EXIT FUNCTION
   '
   i% = INSTR(1, sss$, ".")
   IF i% = 0 THEN
	DROIT$ = "00"
	TEMPOR$ = STR$(res#)
   ELSE
	TEMPOR$ = RIGHT$(sss$, LEN(sss$) - i%)
	LSET DROIT$ = TEMPOR$: TEMPOR% = VAL(DROIT$)
	IF TEMPOR% < 10 THEN LSET DROIT$ = "0" + LTRIM$(STR$(TEMPOR%))
	TEMPOR$ = LEFT$(sss$, i% - 1)
   END IF
   IF VAL(TEMPOR$) > 5940 THEN BEEP: BEEP: USING1$ = "ERREUR ?": EXIT FUNCTION
   TEMPOR% = VAL(TEMPOR$)
   IF TEMPOR% >= 60 THEN
	  HEURE% = FIX(TEMPOR% / 60)
	  SECONDE% = TEMPOR% MOD 60
   ELSE
	  HEURE% = 0
	  SECONDE% = TEMPOR%
   END IF
   HEURE$ = "": IF HEURE% < 10 THEN HEURE$ = "0"
   HEURE$ = HEURE$ + LTRIM$(STR$(HEURE%))
   SECONDE$ = "": IF SECONDE% < 10 THEN SECONDE$ = "0"
   SECONDE$ = SECONDE$ + LTRIM$(STR$(SECONDE%))
   USING1$ = HEURE$ + ":" + SECONDE$ + ":" + DROIT$
END FUNCTION

Coolman · Message par **Coolman** » lun. 17/janv./2005 15:34

Voici une version du code pour Blitzbasic, ce basic n'admet apparement que trois types de variables (integer, float et string), j'ai enlevé plusieurs
sections et adapté le code assez facillement, pour purebasic ca parait plus compliqué, apparement si j'ai bien compris il faut faire suivre une var integer de .i et float de .f, la commande timer peut etre remplace par GetTickCount_(), j'ai enlevé la fonction USING de formatage, j'ai essayé de convertir en pure, resultas en bas de page, mais j'ai un message d'erreur (structure not found) en ligne 3 (de toute facon, la version demo ne gere pas la commande GetTickCount_()), Voici les deux sources :

[/b]

Code : Tout sélectionner

; ************* Code BLITZBASIC **********************************************
boucle% = 32000
Globoucle% = 1000
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
	  Next
		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
	  Next
	  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
	  Next
	  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% = V2% / V1%
	  Next
	  Next
	  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
	  Next
	  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
	  Next
	  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
	  Next
	  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# = V22# / V12#
	  Next
	  Next
	  FIN# = MilliSecs () 
CALC# = (FIN# - DEB#)
Print "DIVISION       : "+Str$(CALC#)
WaitKey()
End



; ****************** Code PUREBASIC ******************************************
OpenConsole() 
Boucle.i = 32000
GloBoucle.i = 1000
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.i = 0: V1.i= 250: V2% = 100
   DEB.f = GetTickCount_()
   For n.i = 1 To GloBoucle.i
   For i.i = 1 To Boucle.i
   res.i = V1.i+ V2.i
   Next
   Next
  FIN.f = GetTickCount_() 
CALC.f = (FIN.f - DEB.f)
Print "ADDITION       : "+Str$(CALC.f)
;******  MODULE TEST  ********************************************************

res.i = 0: V1.i= 250: V2.i = 100
   DEB.f = GetTickCount_() 
   For n.i = 1 To GloBoucle.i
   For i.i = 1 To Boucle.i
   res.i = V1.i- V2.i
   Next
   Next
   FIN.f = GetTickCount_() 
CALC.f = (FIN.f - DEB.f)
Print "SOUSTRACTION   : "+Str$(CALC.f)
;******  MODULE TEST  ********************************************************
res.i = 0: V1.i= 250: V2.i = 100
   DEB.f = GetTickCount_() 
   For n.i = 1 To GloBoucle.i
   For i.i = 1 To Boucle.i
   res.i = V1.i* V2.i
   Next
   Next
   FIN.f = GetTickCount_() 
CALC.f = (FIN.f - DEB.f)
Print "MULTIPLICATION : "+Str$(CALC.f)
;******  MODULE TEST  ********************************************************
res.i = 0: V1.i= 250: V2.i = 100
   DEB.f = GetTickCount_() 
   For n.i = 1 To GloBoucle.i
   For i.i = 1 To Boucle.i
   res.i = V2.i / V1.i
   Next
   Next
   FIN.f = GetTickCount_() 
CALC.f = (FIN.f - DEB.f)
Print "DIVISION       : "+Str$(CALC.f)
;-------------------------------------------------------------------------------
;                    CALCUL SUR LES REELS
Print
Print
Print "CALCUL SUR DES NOMBRES REELS"
Print
res2.f = 0: V12# = 250: V22# = 100
   DEB.f = GetTickCount_() 
   For n.i = 1 To GloBoucle.i
   For i.i = 1 To Boucle.i
   res2.f = V12# + V22#
   Next
   Next
   FIN.f = GetTickCount_() 
CALC.f = (FIN.f - DEB.f)
Print "ADDITION       : "+Str$(CALC.f)
;******  MODULE TEST  ********************************************************
res2.f = 0: V12.f = 250: V22.f = 100
   DEB.f = GetTickCount_() 
   For n.i = 1 To GloBoucle.i
   For i.i = 1 To Boucle.i
   res2.f = V12.f - V22.f
   Next
   Next
   FIN.f = GetTickCount_() 
CALC.f = (FIN.f - DEB.f)
Print "SOUSTRACTION   : "+Str$(CALC.f)
;******  MODULE TEST  ********************************************************
res2.f = 0: V12.f = 250: V22.f = 100
   DEB.f = GetTickCount_() 
   For n.i = 1 To GloBoucle.i
   For i.i = 1 To Boucle.i
   res2.f = V12.f * V22.f
   Next
   Next
   FIN.f = GetTickCount_() 
CALC.f = (FIN.f - DEB.f)
Print "MULTIPLICATION : "+Str$(CALC.f)
;******  MODULE TEST  ********************************************************
res2.f = 0: V12.f = 250: V22.f = 100
   DEB.f = GetTickCount_() 
   For n.i = 1 To GloBoucle.i
   For i.i = 1 To Boucle.i
   res2.f = V22.f / V12.f
   Next
   Next
   FIN.f = GetTickCount_() 
CALC.f = (FIN.f - DEB.f)
Print "DIVISION       : "+Str$(CALC.f)
Delay(3000) 
End

Le Soldat Inconnu

non, en pb, il suffit de faire une seule fois le ".f" et il n'y a plus besoin de donner le type par la suite. cette variable est un float pour tout le programme.
Idem pour .w , .b , .s , les structures, etc...

Backup · Message par **Backup** » lun. 17/janv./2005 17:34

de toute façon tu part sur une fausse donnée du probleme !

le pure basic ,est transformé en assembleur compillé
comme beaucoup de compilateur , il optimise le code
grace a Fred , certains (Denis,Hardy ect..) qui pratique l'assembleur
ont deja demontre le code optimisé et concis generé par le pure basic !!

ensuite un compilateur (dans la mesure du possible) fait un executable

en matiere de performance regarde la taille des executables generés
c'est a mon avis plus parlant qu'une mesure de la vitesse d'une boucle, ou d'un calcul
car de toute façon ces boucles et calculs dependent directement des Processeurs et de la vitesse d'horloge et RAM

donc tes tests sont a mon avis un peu (un peu seulement hein!) Con !

a l'epoqueHebdogiciel demontrait la precision d'un calcul , pour critiquer un processeur , pas un language !!

un language doit etre testé sur sa simplicité de mise en oeuvre
les fonctions (commandes) toute faite , dont il dispose
plus y en a mieux c'est !, et bien sur, sur ses capacitées globales
confort de l'editeur, qualite et taille et stabilité des programmes genérés ect .. !!

perso je prefere un basic qui autorise 2 ecritures ou plus ex:

?"bonjour"
Print "bonjour"
car le "?" me parait plus rapide a ecrire

et bien sur la capacité de faire des "choses" en plus comme
les librairies , les DLLs ,

voila pour moi, comment il faut regarder un language

bref un language qui est suivi , et qui permette le plus de fantaisie possible dans l'ecriture du code , c'est je te le rapelle la Spécificité d'un Basic ! et qui fait que tout a chacun on ecrit avec notre style d'ecriture

oui , il faut laisser les Goto,Gosub, les commandes multiples ":" sur la meme ligne , mem si pour certain c'est une hérésie

pour moi le DarkBasic est le Meilleurs (plus simple)
Basic pour faire de la 3D
et bien qu'il reste des Bug (en correction)
je suis content de mon investissement !!

le Pure Basic est le Meilleur (plus simple) Basic 2D
et comme beaucoup ont attend encore plus ! (bientot peut etre !

)
(les variables dans le For next Step)

bref ! c'est pas la Pioche qui manque de Peche c'est le Jardinier qui est fatigué !!

Vieux proverbe DD (Dobro Delirium)

Coolman · Message par **Coolman** » lun. 17/janv./2005 18:37

*** en matiere de performance regarde la taille des executables generés
c'est a mon avis plus parlant qu'une mesure de la vitesse d'une boucle, ou d'un calcul
car de toute façon ces boucles et calculs dependent directement des Processeurs et de la vitesse d'horloge et RAM

--- Dobro, j'ai deja constaté maintes fois dans tes posts que tu ne prend pas la peine de lire entierement les posts des autres avant d'y repondre, tu le prouves egallement ici, j'ai deja dit que ce genre de test sur differents compilateurs basic doit etre fait sur la meme machine pour se faire une idee de la rapidité des languages...
As tu seulement essayé d'adapter ce simple code a purebasic et a voir les resultas entres les compilateurs pureb ibasicpro et blitzbasic, et bien essaie, poste les resultas et on en reparle...

*** donc tes tests sont a mon avis un peu (un peu seulement hein!) Con ! Very Happy

--- Quant a traiter ce genre de test de con, je ne me serais pas permis personnellement meme si j'ai vu beaucoup plus con sur ce forum et sur d'autres...
j'aurais tout aussi bien pu faire un code avec differents algorithme de tri, ca aurait surement ete plus interessant, mais
ca ne m'aurait avancé a rien car je ne peux quasiment rien tester de serieux avec la version demo de pure, c'est pour cette raison que je m'en suis tenu a un code ultra simple et meme la impossible par exemple d'utiliser la commande GetTickCount_()...

*** a l'epoqueHebdogiciel demontrait la precision d'un calcul , pour critiquer un processeur , pas un language !!

--- Qu'est ca vient faire la dedans, je ne critiques rien, c'est un simple test, une simple boucle avec addition soustraction et multiplication !!!

*** plus y en a mieux c'est !, et bien sur, sur ses capacitées globales
confort de l'editeur, qualite et taille et stabilité des programmes genérés ect .. !!
pour moi le DarkBasic est le Meilleurs (plus simple)

Basic pour faire de la 3D
et bien qu'il reste des Bug (en correction)
je suis content de mon investissement !!

le Pure Basic est le Meilleur (plus simple) Basic 2D
et comme beaucoup ont attend encore plus ! (bientot peut etre ! Very Happy)
(les variables dans le For next Step)

--- Tu as apparement plusieurs basics et probablement beaucoup de temps, je n'ai personnellement pas le temps d'en utiliser plusieurs, j'en cherche un et c'est tout. pour le reste, je me charge de trouver sur le net les libs dlls opensources ou gratuits qui pourrait m'interesser, pour la 3d , il existe plusieurs moteurs gratuits...

[/b]
Pour le reste, j'arrive peniblement a suivre ton raisonnement, comme je l'ai dit plus haut, essaie de lire attentivement les posts des autres avant dy repondre car sinon ca va etre un debat sterile et sans interet... Sans rancune quand meme

Le Soldat Inconnu

regarde la foçnction elapsedmilisecond() de PB, c'est un GetTickCount

comme ça, tu pourras lancer ton code sous PB

Coolman · Message par **Coolman** » lun. 17/janv./2005 19:31

Le Soldat Inconnu a écrit :regarde la foçnction elapsedmilisecond() de PB, c'est un GetTickCount
comme ça, tu pourras lancer ton code sous PB

Cool, je vais voir ca, merci

Backup · Message par **Backup** » lun. 17/janv./2005 23:38

--- Quant a traiter ce genre de test de con, je ne me serais pas permis personnellement meme si j'ai vu beaucoup plus con sur ce forum et sur d'autres...
j'aurais tout aussi bien pu faire un code avec differents algorithme de tri, ca aurait surement ete plus interessant, mais

peut importe le test !!
manifestement t'a pas compris que je trouve tres con d'essayer un language en utilisant un pseudo test pour vérifier la rapidité du dit language !!

j'exprime simplement le fait que c'est pas interressant pour un programmeur
de savoir que tel ou tel Basic va executer une boucle 2% plus vite qu'un autre qui lui executera une copy memoire 2%plus vite !

tout les basic actuel , je parle des plus connus

Dark, Blitz, Purebasic

sont a peut pres equivalent , pour faire des apli ou des jeux grand publique

apres suivant la philosophie du language , (le nom des commandes, parametre ect...)
tu prend celui que tu veux !
tu n'y perdra pas dans tout les cas ! ça reste des Basics !
qui sont tous capable d'afficher des sprite a l'ecran ou des fenetres
c'est l'essentiel !

Tu as apparement plusieurs basics et probablement beaucoup de temps, je n'ai personnellement pas le temps d'en utiliser plusieurs, j'

tu as suffisament de temps pour te poser la question !
si tu avait acheté le purebasic , depuis le debut de ce post tu saurai
que tu n'aurai pas eu a regreter !!

tu passe trop de temps a te poser des question existentiel !

choisi toi un language maintenant !
car a force le language basic sera oublié des memoires et n'existera plus ,que tu sera encore en train de te poser des questions

Qu'est ca vient faire la dedans, je ne critiques rien, c'est un simple test, une simple boucle avec addition soustraction et multiplication !!!

a quoi servent les tests si ce n'es a etre analysés, et donc a etre comparés
et c'est a ce moment qu'intervient la critique !

et oui ! comparer, c'est critiquer !

pour la 3d , il existe plusieurs moteurs gratuits...

oui mais aucun n'est facilement programmable en basic !!

Quant a traiter ce genre de test de con, je ne me serais pas permis personnellement meme si j'ai vu beaucoup plus con sur ce forum

quoi par exemple ??

je me charge de trouver sur le net les libs dlls opensources ou gratuits qui pourrait m'interesser

ben oui ça me surprend pas vraiment !

en purebasic tu les fait toi meme tes DLLs !

en clair tu a besoin de rapidité pour quoi faire ?

de la simulation des fluides ?
de la RDM (resistance des Materiaux)
de l'intelligence artificiel ?
du decodage canal+ en temps reel ?
de dechiffrer les document du site du FBI que tu viens de Hacker ?
tu veux peut etre faire un DSP ou un Transputer en logiciel ?

je crois que tu chipote sur des millisecondes pour Rien !
c'est Mon avis

n'oublie pas qu'il s'agis de BASIC et qu'en ce moment on a quand mem la chance de pouvoir profiter des meilleur basic qu'on ai jamais eu

Blitz ,Dark, purebasic, etc ...

apres , juge plutot l'engouement des forums , c'est plus utile !!

c'est comme ces gens qui veulent savoir si tel ou tel modeleur est le meilleur
certains diront MAYA, d'autres 3DsMax , d'autre AMAPI ect...

peut importe le Crayon , aujourd'hui les differences logiciel , ne concerne pas les utilisateurs , vaut mieux interroger les habitués des differents softs plutot que de vouloir effectuer des test idiots !

demande ici ce qu'on trouve bien et pas bien dans le purebasic
et vas demander dans un forum Blitz la mem chose pour le Blitz ect ...
et apres fait toi une idée !!

ce sera nettement plus judicieux !!

crois moi , je suis un GENIE !!

Le Soldat Inconnu

pfff

Backup · Message par **Backup** » lun. 17/janv./2005 23:58

ok! ok !

Polux · Message par **Polux** » mar. 18/janv./2005 9:29

Pour moi les différences de rapidité des différents basics sont essentielles.. le Dark par exemple est très moyen comparé au pure, et si tu veux réaliser un jeu par exemple, et en balancer plein l'ecran ( et que ça continue de tourner sur la machine du petit frère ), les millisecondes gagnées deviennent précieuses. Sinon tu fais comme certains programmeurs, tu ne regarde pas cet aspect et tu te dis que le gars aura qu'à changé de machine. Ce n'est pas totalement faux ( certaines machines sont réellement obsolètes ) mais ça a ses limites.

Pour les DLLs, effectivement on peut les faire en pure, mais si c'est des DLLs de moteur3D que tu recherche, alors tu t'appelle Carmack si t'es capable de les créer direct en pure. Dans ce cas, les libs opensource sont sacrément utiles et donnent de bons résultats.

peut importe le Crayon , aujourd'hui les differences logiciel , ne concerne pas les utilisateurs , vaut mieux interroger les habitués des differents softs plutot que de vouloir effectuer des test idiots !

là j'ai rien compris...

Après aucun test n'est con, si il est utile à la personne qui le fait. Faut respecter ça.

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

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.