BitShift (unsigned INT)

  • hallo,

    ich suche eine zuverlässige BitShift Funktion, die mit Unsigned-Integer's und großen Zahlen klarkommt (also wie in anderen sprachen eben auch).

    Hab mir schon unzählige workaround-funktionen heruntergeladen, aber keine macht das was sie soll.

  • Ich bin ein wenig verwirrt, die BitShift Funktion in AutoIt tut genau das was man vermuten würde oder?


    Poste doch bitte ein Skriptbeispiel das dein Problem reproduzieren kann (z.B. BitShift(abc, x) = 123, sollte aber eigentlich 234 sein). Dann kann man auch was damit anfangen und eine Lösung finden


    M

  • Ich bin ein wenig verwirrt, die BitShift Funktion in AutoIt tut genau das was man vermuten würde oder?

    Er meint sicher Zahlen, die mit INT nicht mehr darstellbar sind... das Thema hatten wir vor kurzem... im Anhang ist die UDF, die ich dafür benutze.


    _BitShift64(), _BinaryShift()


    PS: Dies ist eine leicht geänderte Version der UDF, die von @Ward stammt.

  • Er meint sicher Zahlen, die mit INT nicht mehr darstellbar sind... das Thema hatten wir vor kurzem... im Anhang ist die UDF, die ich dafür benutze.

    Wollte ich auch gerade vorschlagen :P.

    Die UDF stammt vom User Ward aus dem engl. Forum : Binary UDF - Ward


    Bitnugger :

    Hast Du dort irgendwelche Änderungen vorgenommen ?

    Die UDF's unterscheiden sich, obwohl in beiden Headern :

    ; =============================================================================

    ; AutoIt Binary UDF (2011.9.15)

    ; Purpose: Functions About Binary Type Variable Management

    ; Author: Ward

    ; =============================================================================

    steht.


    EDIT :

    Die Funktionen _BitXOR64, _BitAND64 und _BitOR64 wurden von Bitnugger erweitert. Es können nun 255 Parameter übergeben werden (anstatt 20) - siehe Beitrag #6.

    (EDIT - Ende)


    Mit "... das Thema hatten wir vor kurzem" meinst Du wahrscheinlich : Zahlen größer 64-Bit , oder ?


    Gruß Musashi

    86598-musashi-c64-png

    2 Mal editiert, zuletzt von Musashi () aus folgendem Grund: Thema aktualisiert - Anhang entfernt

  • EDIT: habe die zwei letzten Antworten erst nach meinem post gesehen, versuche das gleich mal .. danke!


    ... und ich habe es mit der Binary.au3 (obere) problemlos hinbekommen!!!


    Danke für die Hilfe!!!

    :party:

  • Hast Du dort irgendwelche Änderungen vorgenommen ?

    Ja, habe ich.


    In dem Script, in dem ich die UDF verwende, benutze ich die AutoIt3Wrapper-Direktive:

    #AutoIt3Wrapper_AU3Check_Parameters=-q -d -w 1 -w 2 -w 3 -w- 4 -w 5 -w 6 -w- 7


    Mit der Original-UDF bricht das Script dann mit Fehlermeldungen ab, weil die Variablen in den Zeilen 408-410 nicht verwendet werden. Deshalb habe ich die Zeilen auskommentiert - ähnlich auch in Zeile 487, wegen dem $Ret.


    Die Funktionen _BitXOR64, _BitAND64 und _BitOR64 habe ich so umgestrickt, dass anstatt 20 Parameter nun 255 übergeben werden können, so wie es bei BitXOR usw. in AutoIt ist.

  • Alles klar, die Erhöhung der Parameteranzahl von 20 auf 255 ist natürlich ein Gewinn.


    Ich wage kaum zu fragen :P, aber könntest Du Dich mit der Idee anfreunden im Header deiner UDF einen Modified-Eintrag zu machen, z.B. :

    ; ===================================================================================

    ; AutoIt Binary UDF (2011.9.15)

    ; Purpose: Functions About Binary Type Variable Management

    ; Author: Ward

    ;

    ; Modified by Bitnugger :

    ; _BitXOR64, _BitAND64 and _BitOR64 now allow 255 parameters to be set instead of 20

    ; ===================================================================================

    (einen Timestamp fügst Du ja bereits automatisch ein)


    Da wir gerade bei dem User Ward sind :

    Kennst Du oder sonst jemand die Hintergründe, warum Ward alle seine Skripte aus dem engl. Forum gelöscht hat ? Da waren wirklich geniale Sachen dabei.


    Gruß Musashi


  • Mit "... das Thema hatten wir vor kurzem" meinst Du wahrscheinlich : Zahlen größer 64-Bit , oder ?


    Gruß Musashi

    Hi,

    da bin ich nochmal - hatte mich da leider zu früh gefreut ...

    denn die Zahlen in meiner Funktion haben teilweise bis 20-Stellen.

    die meisten Rechenaufgaben bekomme ich mit der Bignum.au3 hin.

    Aber die Binary.au3 scheint diese nicht mehr zu unterstützen. z.B.

    Code
    1. _BitXOR64(7169266485658129490,17399588354581095834) = 2054105551196646317 <> 10523109720805372360

    Habt Ihr da noch eine Idee?

    Oder haben wir den Rand des Universums bereits erreicht?

    :Glaskugel:

  • Habt Ihr da noch eine Idee?

    Oder haben wir den Rand des Universums bereits erreicht?

    Den Rand des Universums nicht, wohl aber die Darstellungsgrenze von Int64 ;).

    Beide Deiner Werte sind größer als 9223372036854775807 (2^63 - 1), also dem Maximum von Int64 .

    Genau dafür wurde eigentlich die BigNum.au3 erstellt.


    EDIT :

    UPIA - siehe Beitrag von Ward zu seiner Binary.UDF :

    https://www.autoitscript.com/forum/topic/131037-binary-udf/

    Auszug :

    These functions are just the same as built-in function in the same name but these can handle 64 bit signed integer :

    _BitShift64($Value, $Shift)

    _BitRotate64($Value, $Shift)

    _BitNOT64($Value)

    _BitOR64($Value1, $Value2, [$Value3, ...])

    _BitAND64($Value1, $Value2, [$Value3, ...])

    _BitXOR64($Value1, $Value2, [$Value3, ...])

    _Hex64($Value, $Length = 16)

    _Dec64($HexString)


    Die Kernaussage hier lautet : "... these can handle 64 bit signed integer"

    Daher ist der höchste (positive) Wert für Int64 (2^63 -1) = 9223372036854775807, da ein Bit für das Vorzeichen verwendet wird.

    (EDIT Ende)


    Gruß Musashi

  • ja aber natürlich sprach ich vom Zahlenuniversum :-)


    Für Multiplikation, Division, etc ist die Bignum.au3 ja super (hatte die auch schon im Einsatz),

    aber da ist ja keine BitXOR drin (oder hab ich was übersehen?).

    und die _BitXOR64 wirft mir bei sehr großen Zahlen (> 64bit) ein anderes Ergebnis aus als C++ (das hatte ich beim Schnelltesten der Binary.au3 übersehen)

    Code
    1. _BitXOR64(7169266485658129490, 17399588354581095834)

    sry, hatte mich da nicht klar ausgedrückt ..

  • ... die _BitXOR64 wirft mir bei sehr großen Zahlen (> 64bit) ein anderes Ergebnis aus als C++ (das hatte ich beim Schnelltesten der Binary.au3 übersehen)

    Der Grund ist, dass die Binary.UDF mit 64 Bit Signed-Integern arbeitet. Da ich dafür keinen neuen Beitrag schreiben wollte, habe ich das im Beitrag #10 hinzugefügt - hast Du ggf. nicht mitbekommen ;).


    Für Multiplikation, Division, etc ist die Bignum.au3 ja super (hatte die auch schon im Einsatz),

    aber da ist ja keine BitXOR drin (oder hab ich was übersehen ?).

    Da ich bisher nicht mit der BigNum.UDF gearbeitet habe, kann ich dazu nichts sagen. Es ist aber sicher möglich, dass man dbzgl. eine entsprechende Erweiterung schreiben kann.


    Gruß Musashi

  • Naja,

    das ist für einen Programmieranfänger doch nur eine Fleißaufgabe.

    Eine beliebig große Anzahl "Ziffern" ins entsprechende Binärformat bzw Hex umwandeln, und "blockweise" 64Bit wie gehabt XORen. Imho hatten wir das unlängst sogar hier im Forum.


    Suche (schnelle) Funktion zum Umrechnen ins Dual- oder Hexadezimalsystem


    hups...."unlängst"....5 Jahre her, aber trotz meines biblischen Alters habe ich mich noch dran erinnert^^

    Link zum Post mit einem letztendlich schnellen Script: Suche (schnelle) Funktion zum Umrechnen ins Dual- oder Hexadezimalsystem

  • Erfreulich zu sehen, dass das Gedächtnis bei jüngeren Leuten noch so gut funktioniert ;).


    UPIA :

    Der Hinweis von Andy (Skript von eukalyptus) ist - wie gewohnt - sehr hilfreich.

    Die Umwandlung Dezimalstring <-> Binärstring ist schnell und 'idiotensicher'.

    Für eine eigene XOR Funktion solltest Du kürzere Binärstrings linksseitig mit Nullen auffüllen (auf die Länge des 'längsten' Binärstrings). Ob Du die Verknüpfung dann blockweise machst oder Bit für Bit, ist Dir überlassen.


    eukalyptus :

    In Deinem Skript gab es (meiner Meinung nach) noch eine kleine Definitionslücke :

    Besetzt man den Dezimalstring mit "0", dann liefert _BigNum_DecToBin() einen Leerstring zurück. Dezimal="0" soll aber sicher auch Binär="0" ergeben. Ich habe einen simplen Fix eingebaut.


    Gruß Musashi

  • Erfreulich zu sehen, dass das Gedächtnis bei jüngeren Leuten noch so gut funktioniert

    Hehe :o), werd du erst mal so alt, wie ich aussehe 8o



    Für eine eigene XOR Funktion solltest Du kürzere Binärstrings linksseitig mit Nullen auffüllen (auf die Länge des 'längsten' Binärstrings). Ob Du die Verknüpfung dann blockweise machst oder Bit für Bit, ist Dir überlassen.

    Da das hier ja ein Programmier(er)forum ist, sollte der geneigte "User" eine Funktion erstellen und diese dann hier posten, so dass man sie in die BigNum.UDF übernehmen kann.:rock:

    Wie gesagt, eine "kleinere" Programmierübung. Das sollte auch ein Anfänger schaffen.

  • Habe die in Post #3 von mir geänderte Binary.au3 nochmals ein wenig umgeändert.


    Und weil es zum Thema passt, findet ihr hier im Anhang noch eine kleine UDF von mir...

    Funktionen: _BinaryMidAND, _BinaryMidNOT, _BinaryMidOR, _BinaryMidXOR