PureBoard

Verfasst: **19.11.2004 16:51**

a = 10
Debug (30<40) ; Ergebnis 1
Debug (40<30) ; Ergebnis 0
Debug (a<30)  ; Ergebnis 30, erwartet 1
Debug (a>30)  ; Ergebnis 30, erwartet 0

Die Ergebnisse sind verblüffend.
Dies ist bestimmt schon hier diskutiert worden.
Wird sich PB in dieser Hinsicht ändern ?

Verfasst: **19.11.2004 16:57**

Man kann imo derzeit nur konstante Werte so vergleichen. Variablen werden vielleicht noch folgen, wer weiß?

Verfasst: **19.11.2004 17:13**

ich wiederhole mich: sollten sie (bitte). das effektivste einsatzgebiet für boolesche ausdrücke ist nunmal der einsatz mit variablen.

Verfasst: **19.11.2004 17:24**

Nimmt man halt erstmal ne If Abfrage, obwohl Boolsche Ausdrücke
natürlich schon sexy sind

Verfasst: **19.11.2004 17:33**

nicht nur sexy, sondern auch x-mal schneller.
(war jedenfalls in anderen sprachen so, vielleicht ist PB da ja ne ausnahme

)

Verfasst: **19.11.2004 18:57**

Kaeru Gaman hat geschrieben:nicht nur sexy, sondern auch x-mal schneller.
(war jedenfalls in anderen sprachen so, vielleicht ist PB da ja ne ausnahme )

Wunder gibt es immer wieder.

In VB ist es zumindest so, daß beispielsweise ein Select-Case schneller ist als
eine If-Else-Endif-Abfrage. In PB ist es genau umgekehrt. Ebenso verhält es
sich mit "If Len(String)=0", welches in VB schneller ist als die If String = "" -
Abfrage.

Code: Alles auswählen

Enumeration
  #LIG
EndEnumeration

Procedure Test1()
  
  sDummy.s = "Hallo"
  
  z1 = ElapsedMilliseconds()
  For lCounter =0 To 10000000
    If sDummy = ""
      lDummy = 1
    EndIf
  Next 
  z2 = ElapsedMilliseconds()
  
  ; -------------
  AddGadgetItem(#LIG,-1,"If String = " + Chr(34) + Chr(34) + #LF$ + Str(z2-z1))
  ; -------------
  
  z1 = ElapsedMilliseconds()
  For lCounter =0 To 10000000
    If Len(sDummy) = 0
      lDummy = 1
    EndIf
  Next 
  z2 = ElapsedMilliseconds()
  
  ; -------------
  AddGadgetItem(#LIG,-1,"If Len(String) = 0" + #LF$ + Str(z2-z1))
  ; -------------
  
  
EndProcedure

Procedure Test2()
  
  z1 = ElapsedMilliseconds()
  For lCounter =0 To 10000000
    If Sqr(2)=1
    ElseIf Sqr(2)=2
    ElseIf Sqr(2)=3
    ElseIf Sqr(2)=4
    ElseIf Sqr(2)=5
    EndIf
  Next 
  z2 = ElapsedMilliseconds()
  
  ; -------------
  AddGadgetItem(#LIG,-1,"If Else Endif" + #LF$ + Str(z2-z1))
  ; -------------
  
  z1 = ElapsedMilliseconds()
  For lCounter =0 To 10000000
    Select Sqr(2)
      Case 1
      Case 2
      Case 3
      Case 4
      Case 5
    EndSelect
  Next 
  z2 = ElapsedMilliseconds()
  
  ; -------------
  AddGadgetItem(#LIG,-1,"Select Case" + #LF$ + Str(z2-z1))
  ; -------------
  
EndProcedure


If OpenWindow(0,0,0,230,100,#PB_Window_SystemMenu|#PB_Window_ScreenCentered,"Kleinen Augenblick Geduld...") 
  
  If CreateGadgetList(WindowID()) 
    ListIconGadget(#LIG, 10, 10, 210, 80, "Aktion", 150, #PB_ListIcon_GridLines) 
    AddGadgetColumn(#LIG,1,"Zeit",50) 
  EndIf 
  
  Test1()
  Test2()
  
  SetWindowTitle(0,"Kleiner Performance-Test")
  
  Repeat 
    EventID = WaitWindowEvent() 
  Until EventID = #PB_Event_CloseWindow 
  
EndIf

kann aber auch sein, daß ich mich da verhauen habe...

Grüße ... Kiffi

Verfasst: **19.11.2004 19:23**

hmmm, interessant.

ich kann ja leider nicht austesten, ob booleans schneller sind.
um es mal zu verdeutlichen (ich wiederhole mich):

x-koordinaten-begrenzung für 32er Sprite auf 800er screen (auftauchen gegenüber)

Sx = Sprite-X , vx = X-Geschwindigkeit

klassisch (funktioniert):

Code: Alles auswählen

Sx + vx
If Sx < -32 : Sx + 832 : EndIf
If Sx > 800 : SX - 832 : EndIf

und mit Booleans (funktioniert NICHT):

Code: Alles auswählen

Sx + vx + 832*(Sx<-32) - 832*(Sx>800)

anmerkung: die Beiden Codes sind wahrscheinlich nicht wirklich identisch, da beim zweiten möglicherweise das Sx ohne vx in die abfrage einfliessen würde (was bei C anders wäre)

in C wäre der zweite Code merklich schneller.

mal die Frage ans TEAM: wäre das in PB auch schneller, wenn man variablen in booleans verwenden könnte ?

Verfasst: **20.11.2004 02:21**

@Kaeru: kann die Frage leider nicht selbst beantworten. Habe Fred angeschrieben und um Rückinfo gebeten. Melde mich dann mit mehr Infos...

Verfasst: **20.11.2004 14:37**

danke, andre

mir gehts halt darum:

wenn es wirklich schneller wäre, plädiere ich dafür, es zu implementieren.

wenn es langsamer wäre, kann fred sich die arbeit sparen, dann werden halt weiterhin IFs gesetzt.

wenn es gleichschnell wäre, wäre es schon interessant, zumindest um einen modernen C-like-style zu ermöglichen

Verfasst: **22.11.2004 23:02**

Vor allen Dingen sollte die Logik stimmen und der Code keinen Unsinn produzieren.
Wenn der Ausdruck (b<60) die 60 als Ergebnis zurückgibt, dann ist das meiner Meinung nach schlicht falsch.
Entweder muss dann der Compiler solche Konstruktionen unterbinden, oder aber das tun, was er bei der If - Abfrage auch tut, den Ausdruck richtig nach True oder False auflösen.
In diesem Zusammenhang fällt mir eine Diskussion aus dem englischen Forum ein, bei der es um das Setzen von Defaults für Prozedurparameter geht. Dort wird ernsthaft diskutiert, dafür die Syntax ProcName(a.l , b = 3, c.w) auszuwählen.
Ist aber b = 3 nicht auch ein boolescher Wert?

Abgesehen von Geschwindigkeitsvorteilen, ich finde

Code: Alles auswählen

SetGadgetState(#Gadget, (Z>45))

einfach besser als

Code: Alles auswählen

If Z > 45
  SetGadgetState(#Gadget, #True)
Else
  SetGadgetState(#Gadget, #False)
Endif

PureBoard

Behandlung von Booleans

Behandlung von Booleans