Basic = Schlecht

[Kaeru Gaman]

ok, das ist nachvollziehbar.

ich könnte mir vorstellen, dass die aufgabe mit absicht so gestellt ist,
dass man sich mit dem quad-problem auseinandersetzen muss.
der dozent hätte ja auch eine aufgabe wählen können, die sich im long-zahlenraum bewerkstelligen lässt...

[ZeHa]

Mal 'ne ganz blöde Frage, wo kann ich eigentlich den ASM-Output ansehen, den PB generiert? Ich hab das noch nie gecheckt, in welcher Datei der zu finden ist. Wird der nach dem assemblieren sofort gelöscht? Wenn ja, wie verhinder ich das?

[edel]

pbcompiler /comented source.pb

PureBasic.asm findest du dann im Compiler Ordner.

[Kaeru Gaman]

öh.. hat mir letztens ein kollege gesagt, hab ich aber wieder vergessen...

noch was anderes:
wie habt ihr denn die zeitmessung gemacht, bei eurer aufgabe?
...mit ElapsedMilli is das nämlich unfug...
mit nur 100000 durchläufen bekomm ich kein ergebnis..


ok.. rumgetestet.. wirklich aussagekräftige ergebnisse bekomme ich bei einer Milliarde durchläufen, nich bei läppischen Hunderttausend, die sind nicht messbar.

hier in optimiertem PB:

Code: Alles auswählen

fac.d = 2
run.l = 3
ite.l = 0

timer = ElapsedMilliseconds()
While ite < 1000000000
  While run < 171
    fac * run
    run +1
  Wend
  ite+1
Wend
timer = ElapsedMilliseconds() -timer

MessageRequester("B.I.G. Algoboo","170! = "+StrD(fac) + #CRLF$ + "Timer: "+Str(timer))

PS:
mit doubles brauchts bei mir knapp 2.5sec, mit quads ne ganze sekunde länger...

[edit]
STOP
habs grad selbst gesehen... bitte code ignorieren...

[Green Snake]

PB: 18176
(Dev)C++ :22162

Durchläufe: 10000000


Edit:
Mit Kaerus Code: 7330

[#NULL]

@zeha
mit GetDisASMString() kannst du auch den asm einzelner teile von code einsehen. mußt dir mal das beispiel ansehen.

[ZeHa]

Okay habe mal nun den folgenden kleinen Test gemacht:

Code: Alles auswählen

a = 100
b = 100

c = a*b

den gleichen Test danach noch einmal als Quad-Version.
Hier die ASM-Outputs:

32 Bit

Code: Alles auswählen

; a = 100
  MOV    dword [v_a],100
; b = 500
  MOV    dword [v_b],500
; 
; c = a*b
  MOV    ebx,dword [v_a]
  IMUL   ebx,dword [v_b]
  MOV    dword [v_c],ebx

64 Bit

Code: Alles auswählen

; a.q = 100
  MOV    dword [v_a],100
  MOV    dword [v_a+4],0
; b.q = 500
  MOV    dword [v_b],500
  MOV    dword [v_b+4],0
; 
; c.q = a*b
  MOV    ebx,dword [v_a]
  MOV    edi,dword [v_a+4]
  LEA    eax,qword [v_b]
  PUSH   dword [eax+4]
  PUSH   dword [eax]
  PUSH   edi
  PUSH   ebx
  CALL   Mul64
  MOV    ebx,eax
  MOV    edi,edx
  PUSH   edi
  PUSH   ebx
  POP    dword [v_c]
  POP    dword [v_c+4]

[Kaeru Gaman]

mann mann mann... so ein blöder fehler... *im boden versink*

ok, habs jetzt nochmal durchgesehen...

habe manunidis code mit eingebaut, mit quads, longs sin geschummelt, das gildet nich.

Code: Alles auswählen

;*** PB w/ doubles
ite1.l = 0
timer= ElapsedMilliseconds()
While ite1 < 1000000
fac1.d = 2
run1.l = 3
  While run1 < 171
    fac1 * run1
    run1 +1
  Wend
  ite1+1
Wend
timer1= ElapsedMilliseconds() -timer

;*** PB w/ quads
ite2.l = 0
timer= ElapsedMilliseconds()
While ite2 < 1000000
fac2.q = 2
run2.l = 3
  While run2 < 171
    fac2 * run2
    run2 +1
  Wend
  ite2+1
Wend
timer2= ElapsedMilliseconds() -timer

;*** PB w/ doubles
ite3.l = 1
timer= ElapsedMilliseconds()
While ite3 <= 1000000
fac3.d = 2
run3.l = 3
  While run3 <= 170
    fac3 * run1
    run3 +1
  Wend
  ite3+1
Wend
timer3= ElapsedMilliseconds() -timer

;**********************************************
;Variablendeklarationen 
zaehler.l   = 1 
fakultaet.q = 1 
i.l         = 1 
x.l         = 170 
d.l         = 1000000 
StartTime.l = ElapsedMilliseconds() ;Start der Zeitmessung 
While i <= d 
  zaehler   = 1 
  fakultaet = 1 
    While zaehler <= x 
      fakultaet * zaehler 
      zaehler + 1 
    Wend 
  i + 1 
Wend 
Timer4 = ElapsedMilliseconds()-StartTime  ;Berechnen der benötigten Zeit
;**********************************************

out$ = "KG d<: "+Str(timer1) + #CRLF$
out$ + "KG q<: "+Str(timer2) + #CRLF$
out$ + "KG d<=: "+Str(timer3) + #CRLF$
out$ + "manunidi q: "+Str(timer4)
MessageRequester("170!",out$)

KG d<: 1016,1015,1000
KG q<: 1875,1860,1875
KG d<=: 1016,1031,1016
manunidi q: 1828,1828,1828

[Zaphod]

Größere userlibs für PB schreibt man besser in C, wenn man an seinem Verstand hängt. Sowas in puren Assembly zu machen ist schwachsinn, dafür ist Assembly nicht gedacht.

Mal gucken wann der Punkt erreicht ist.

Nie *g*
Wenn dir wirklich was fehlt in PureBasic, dann macht es meiner Meinung nach mehr Sinn Assembler zu lernen. Das kannst du schön mit PB kombinieren und damit zeitkritische Aufgaben optimieren oder dir Funktionen basteln die dir PB nicht bietet.

Für mich ist C/C++ viel zu umständlich. Also ich meine so sinnfreie Dinge wie ein Semikolon am Ende jeden Befehls. Mal erlich, wozu soll das gut sein?

Damit man wenn man Bock hat auchmal zwei kurze zeilen auf einer Zeile schreiben kann. Ich kann es nicht fassen an was für lächerliche kleinigkeiten sich manche unerfahrenen Programmierer hängen. Das Semikolon am ende ist doch überhaupt kein Argument.

Ihr könnt ja mal nen kleinen Wettbewerb machen. Eine bestimmte Aufgabenstellung und wer schneller dafür ein Programm geschrieben hat, der hat gewonnen. Ich wette mit PB liegst du da ne Nasenspitze vor C/C++.

Damit könnte man zeigen in welcher Sprache schneller entwickelt werden kann, aber nicht welches Programm die aufgabe schneller löst.
Das würde leider auch nicht viel aussagekraft besitzen, denn das wäre extrem abhängig von den Bibliotheken die der C++ nutzer verwendet hätte. Auch würden einige Aufgaben PB stark bevorzugen, andere C++. Zb ist es viel einfacher eine Aktuelle 3D Engine zusammen mit einer aktuellen Physik Engine in C++ zu nutzen, weil fast alle verfügbaren SDKs für C++ sind.

Auch gibt es Sprachen, in denen einige Aufgaben in einem Bruchteil des Codes erledigt werden können, der in PB UND in C nötig wären (Falls es dir nicht aufgefallen ist, PB und C ähneln sich sehr stark),
zb in Python oder in Funktionalen Sprachen wie Haskell. Soll das jetzt bedeuten PB ist schlecht?

Bevor man Programmiersprachen beurteilt sollte man mindestens 4-5 Programmiersprachen sehr gut beherschen, am besten Programmiersprachen die möglichst unterschiedliche Paradigmen umsetzen.

[FloHimself]

Also ich meine so sinnfreie Dinge wie ein Semikolon am Ende jeden Befehls. Mal erlich, wozu soll das gut sein?

Das Semikolon hat durchaus einen Sinn. Vielleicht mal etwas mit der Sprache beschäftigen, bevor du dir voreilig eine Meinung bildest.