Formelfrage

[Justin]

Hallo zusammen,

wie kann ich folgendes mit PureBasic berechnen:

15 ^ 48

"^" gibt es ja nicht als Operator

Gruß
Justin

[NicknameFJ]

Hallo,

pow() ist das Zauberwort.

Grüße nicknamefj

[RSBasic]

Siehe Pow().

\\Edit:
Zu langsam.^^

[Justin]

mensch, super - vielen Dank euch beiden !

Gruß
Justin

[STARGÅTE]

An dieser Stelle möchte ich jedoch darauf hinweisen, dass Pow() für Floats/Doubles ist.
Das sage ich dehalb, weil sonst die frage wieder aufkommt, warum das Ergebnis "falsch" ist:

Code: Alles auswählen

Debug Pow(15,48)

Die PB-Ausgabe ist:
283387333428466480000000000000000000000000000000000000000.0
Was richtig ist, weil wir ja nur mit Doubles arbeiten
Wirklich richtig ist jedoch:
283387333428466483068181247517713927663862705230712890625
Jedoch reicht dafür die Genauigkeit von Doubles nicht aus.

[Justin]

Moin,

ja also dann liegt wohl folgendes außerhalb des Machbaren:

Code: Alles auswählen

(1 + 1)*2^48 + 1*2^32 + 1101*2^16 + 28106

Gibt es da eine Möglichkeit soetwas zu berechnen - mir würde als ergebnis auch ein String ausreichen?

Gruß
Justin

[NicTheQuick]

Nein, das liegt wiederum im Machbaren, weil man z.B. mit Quads Zahlen bis 2^63 darstellen kann. Aber statt a * 2 ^ b kann man in dem Fall auch einfach a << b schreiben, also den Wert von a auf Binärebene um b Bits verschieben.

Code: Alles auswählen

;(1 + 1)*2^48 + 1*2^32 + 1101*2^16 + 28106 

Define.q i = (1 + 1) << 48 + 1 << 32 + 1101 << 16 + 2816
Debug i

Allerdings klappt das mit der 15 ^ 48 nicht mehr so einfach.

[CSHW89]

Oder falls es dann doch keine Zweierpotenzen sind, dann so:

Code: Alles auswählen

Procedure.q PowQ(basis.i, exponent.i)
  Protected rest, powq.q
  
  If (exponent > 2)
    ; e gerade:   b^e = (b^(e/2))^2
    ; e ungerade: b^e = (b^((e-1)/2))^2 * b
    
    rest = exponent & 1 ; rest = exponent % 2
    exponent >> 1       ; exponent = exponent / 2
    powq = PowQ(basis, exponent)
    powq * powq
    If (rest <> 0)
      powq * basis
    EndIf
    ProcedureReturn powq
    
  ElseIf (exponent = 2)
    ProcedureReturn basis * basis
    
  ElseIf (exponent = 1)
    ProcedureReturn basis
    
  ElseIf (exponent = 0)
    ProcedureReturn 1
    
  Else
    ; Fehler!
    ProcedureReturn 0
    
  EndIf
EndProcedure


Debug PowQ(15, 12)
Debug Pow (15, 12)
Debug PowQ(2, 62) + PowQ(2, 1)
Debug StrD(Pow(2, 62) + Pow(2, 1),1) + " <- Fehler bei Pow"
Debug PowQ(-3, 13)
Debug Pow (-3, 13)

Dieser Code funktioniert genauer als Pow bei Zahlen zwischen -2^63 und 2^63. Darüberhinaus kommt allerdings murks raus

lg Kevin

[Nino]

@CSHW89:
Erweitere die Liste Deiner Test-Aufrufe doch mal um folgende Zeilen:

Code: Alles auswählen

Debug PowQ(0, 0)
Debug Pow (0, 0)

Es gibt gibt in der Mathematik eine alte Diskussion darüber, welchen Wert 0^0 haben soll (0, 1 oder unbestimmt). Da der Wert dieses Ausdrucks in PureBasic (ebenso wie in vielen anderen Programmiersprachen) 1 ist, würde ich die Funktion PowQ() so schreiben, dass sie in dem Fall ebenfalls 1 zurückgibt.

Grüße, Nino

[CSHW89]

Naja ich bin eher der Verfechter der Aussage, dass 0^0 nicht definiert ist, sondern nur der Grenzwert von x^x, für x->0, gleich 1 ist. Aber falls du es ändern willst, dann müsstest du nur einen Fall rausschmeißen:
Aus...

Code: Alles auswählen

ElseIf (exponent = 0)
  If (basis = 0)
    ProcedureReturn 0
  Else
    ProcedureReturn 1
  EndIf

wird...

Code: Alles auswählen

ElseIf (exponent = 0)
  ProcedureReturn 1

Die 0 war eigentlich als Fehler gedacht, genauso wie bei einem negativen Exponenten, da ich ja nur ganze Zahlen betrachte.
lg Kevin