Behandlung von Booleans

[jear]

Code: Alles auswählen

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 ?

[Ynnus]

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

[Kaeru Gaman]

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

[Lars]

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

[Kaeru Gaman]

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

[Kiffi]

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

[Kaeru Gaman]

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 ?

[Andre]

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

[Kaeru Gaman]

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

[jear]

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