BITAND and the limit of 2147483647

[Joboy2k]

Hi there, I'm trying to find a different method (or maybe a way around) to BITAND which has a limit of 2147483647

Im using it in a program that uses the power of 2 to store which accessories an item has. I.E

Accessorie 1 = 1

Accessorie 2 = 2

Accessorie 3 = 4

Accessorie 4 = 8

So with a result of 14 I know its Accessories 2, 3 and 4.

I didn't realise there was a limit and have accessories up to 17592186044416 which is 45 accessories.

Obviously i'm hitting issues as soon as I need to use accessories 32 and up as that's when it hits 2147483648 which is 1 above the limit.

If BitAND($Binary, $AccessoriesTemp[$i][2]) > 0 then
    $AccessoriesTemp[$i][3] = 0
EndIf

This if statement lets everything through if the $binary number is 2147483648 or above, as its stuck with the limit of 2147483647. is there a better method to store data rather than with the power of 2 method, or am I doing something wrong with the BITAND function?

Thanks in advance

[water]

It depends on the goal you want to achieve:

• Performance
• The need to know which accessories are used by an item
• ...

To my mind come Arrays and Dictionaries.

 

[RTFC]

https://www.autoitscript.com/forum/topic/185621-bitwise-operations-with-64-bit-integers/

[Joboy2k]

When equipment is saved all the accessories that are checked in a listview that are with that equipment will be scanned through and all there values are added together and saved into a sqlite database. When that equipment item Is reopened in the future the total is given and then goes through BITAND to work out which ones were used to make that total. 

I used to use a long conveluted method like this

$Calculation = ""
$Total = $REP_Accessoriestotalread  ;  Binary total
Array = StringSplit($Accessoriesbinary, "|")  ;  List of all possible binary numbers
$i = $Array[0] 
Do
    If Number($Total) >= Number($Array[$i]) Then
        $Total -= $Array[$i]
        If $Calculation = "" Then
            $Calculation &= $Array[$i]
        Else
            $Calculation &= "|" & $Array[$i]
        EndIf
    EndIf
    $i -= 1
Until $i = 0

 

This would just give me string (which I would then split into an array) of all the individual binary numbers which I the would need to do another loop after checking the number against the complete binary array and then entering those details into a listview. was hoping to get away from this as the BITAND work so amazingly with only a few lines of code but didn't realise some of the less used ones with higher numbers messes everything up. do you recon I should go back to my original method if im going to have numbers higher than 2147483647?

[Joboy2k]

I will take a look at that RTFC. I've got to admit I still don't fully understand BIT operations even with reading everything around but I will try and look at and use that UDF. 

Thank you

[water]

I would fill an array with the data you retrieve from the listview (if item 4 is checked then array element 4 gets set to "x" (or whichever value you prefer)).
Then create a string out of the array using _ArrayToString ("|" or any other character as delimiter) and store this string in your DB.
To fill the listview you read the datafield from your DB, split the string with the selected delimiter into an array. Then loop through the array and fill the listview with the used accessories.
This way you can store a nearly unlimited number of accessories and do not need to change the structure of your DB when you change the number of accessories.

Edited March 23, 2020 by water

[Joboy2k]

The only issue I have with that method water is sometime the accessories change name slightly. So if in the future the accessories change slightly the equipment already booked in will have accessories noted that don't exist, with the number method its like its own ID. 

 

Thinking about it I might do what you've said but with an ID number. I've had a program running years at a company that uses the old looping system with a binary number total but I can incorporate something into my program that will scan through the database on first run and convert all the current ones to a string of numbers that can be split up.

 

Thank you both for the help. 

[water]

Using an ID would have been my next suggestion

[jchd]

For 64-bit bitwise operations ther's also this:

Now, when storing such things in SQLite, the recommended way is to setup a foreign key to accessories referencing main items.

[BrewManNH]

I'd use BitOr to find out which bits are set.

[TheXman]

1 hour ago, BrewManNH said:

I'd use BitOr to find out which bits are set.

@BrewManNH

A bitwise OR is commonly used to set 1 or more bits.  A bitwise AND is commonly used to test if one or more bits are set. 

How exactly would you use a bitwise OR to find out which bits are set?

[Nine]

Here I made recap of the UDFs compare to native operators.  There is a know issue that won't be resolved with native ^ (power), and of course BITand only work at 32 bits.  Changes must be made to j0kky UDF cause it suffers from the same power issue.  Only JCHD UDF works as expected.

expandcollapse popup

;#AutoIt3Wrapper_UseX64=y
#include "addons.au3"
#include "64 bits Integer.au3"

; known "issue" that won't be fixed : https://www.autoitscript.com/trac/autoit/ticket/3703
; Table of : https://en.wikipedia.org/wiki/Power_of_two

Example1()
Example2()
Example3()

; =======  Native operators ========
Func Example1 ()
ConsoleWrite ("=======  Native operators ========" & @CRLF)
For $i = 45 to 63
  $var1 = 2^$i
  ConsoleWrite ($i & @TAB & VarGetType($var1) & " / " & $var1 & " / " & Int($var1,2) & " / " & BitAND($var1,0xFFFFFFFFFFFFFFFF) & @CRLF)
Next
EndFunc

; =======  JCHD UDF ========
Func Example2 ()
ConsoleWrite ("=======  JCHD UDF ========" & @CRLF)
For $i = 45 to 63
  $hex = hex (2^($i-32),8) & "00000000"
  $uInt1 = Dec($hex,2) ; or _HexToInt64($hex)
  $uInt2 = Dec('FFFFFFFFFFFFFFFF',2) ; or _HexToInt64('FFFFFFFFFFFFFFFF')
  ConsoleWrite ($i & @TAB & $uInt1 & " / " & _BitAnd($uInt1, $uInt2) & @CRLF)
Next
EndFunc

; =======  j0kky UDF ========

Func Example3 ()
ConsoleWrite ("=======  j0kky UDF ========" & @CRLF)
For $i = 45 to 63
  $hex = hex (2^($i-32),8) & "00000000"
  $uInt1 = Dec($hex,2)
  $uInt2 = Dec("FFFFFFFFFFFFFFFF",2)
  ConsoleWrite ($i & @TAB & $uInt1 & " / " & _BitAnd64($uInt1, $uInt2) & @CRLF)
Next
EndFunc

 

Edited March 23, 2020 by Nine

[Nine]

Ok corrected j0kky code to work nicely both x86 and x64 

expandcollapse popup

#AutoIt3Wrapper_UseX64=y

For $i = 45 To 63
  $hex = Hex(2 ^ ($i - 32), 8) & "00000000"
  $uInt1 = Dec($hex, 2)
  $uInt2 = Dec("FFFFFFFFFFFFFFFF", 2)
  ConsoleWrite($i & @TAB & $uInt1 & " / " & _BitAND64($uInt1, $uInt2) & @CRLF)
Next

Func _BitAND64($iValue1, $iValue2)
  If Not ((VarGetType($iValue1) = "Int64") Or (VarGetType($iValue2) = "Int64")) Then Return BitAND($iValue1, $iValue2)
  $iValue1 = __DecToBin64($iValue1)
  $iValue2 = __DecToBin64($iValue2)
  Local $aValueANDed[64], $i
  For $i = 0 To 63
    $aValueANDed[$i] = ($iValue1[$i] And $iValue2[$i]) ? 1 : 0
  Next
  Return __BinToDec64($aValueANDed)
EndFunc   ;==>_BitAND64

Func _BitOR64($iValue1, $iValue2)
  If Not ((VarGetType($iValue1) = "Int64") Or (VarGetType($iValue2) = "Int64")) Then Return BitOR($iValue1, $iValue2)
  $iValue1 = __DecToBin64($iValue1)
  $iValue2 = __DecToBin64($iValue2)
  Local $aValueORed[64], $i
  For $i = 0 To 63
    $aValueORed[$i] = ($iValue1[$i] Or $iValue2[$i]) ? 1 : 0
  Next
  Return __BinToDec64($aValueORed)
EndFunc   ;==>_BitOR64

Func _BitXOR64($iValue1, $iValue2)
  If Not ((VarGetType($iValue1) = "Int64") Or (VarGetType($iValue2) = "Int64")) Then Return BitXOR($iValue1, $iValue2)
  $iValue1 = __DecToBin64($iValue1)
  $iValue2 = __DecToBin64($iValue2)
  Local $aValueXORed[64], $i
  For $i = 0 To 63
    $aValueXORed[$i] = (($iValue1[$i] And (Not $iValue2[$i])) Or ((Not $iValue1[$i]) And $iValue2)) ? 1 : 0
  Next
  Return __BinToDec64($aValueXORed)
EndFunc   ;==>_BitXOR64

Func _BitNOT64($iValue)
  If Not (VarGetType($iValue) = "Int64") Then Return BitNOT($iValue)
  $iValue = __DecToBin64($iValue)
  For $i = 0 To 63
    $iValue[$i] = Not $iValue[$i]
  Next
  Return __BinToDec64($iValue)
EndFunc   ;==>_BitNOT64

Func __DecToBin64($iDec)
  Local $tI64 = DllStructCreate("int64 num"), $aBin[64], $iVal
  Local $tI32 = DllStructCreate("align 4;uint low;uint high", DllStructGetPtr($tI64))
  $tI64.num = $iDec
  For $i = 0 To 31
    $iVal = 2 ^ $i
    $aBin[$i] = BitAND($tI32.low, $iVal) ? 1 : 0
    $aBin[$i + 32] = BitAND($tI32.high, $iVal) ? 1 : 0
  Next
  Return $aBin
EndFunc   ;==>__DecToBin64

Func __BinToDec64($aBin)
  Local $tI32 = DllStructCreate("align 4;uint low;uint high"), $iVal
  Local $tI64 = DllStructCreate("UINT64 num", DllStructGetPtr($tI32))
  For $i = 0 To 31
    $iVal = 2 ^ $i
    $tI32.low += $aBin[$i] ? $iVal : 0
    $tI32.high += $aBin[$i + 32] ? $iVal : 0
  Next
  Return $tI64.num
EndFunc   ;==>__BinToDec64

 

[Joboy2k]

That is brilliant thank you Nine, I will incorporate that into the program and see how it runs. Thank you all for the amount of help you have all provided. Im still a little unsure on exactly how Bit calculations work but with these UDF's I can watch them work and hopefully understand them better.

 

Many thanks for all the help with such small amount of information.

[BrewManNH]

8 hours ago, TheXman said:

A bitwise OR is commonly used to set 1 or more bits. 

Yeah, you're right, was thinking backwards.

[dmob]

I had same problem storing user & program options (which grow periodically when need arises)  in my app.

I ditched that method in favour of JSON since I use SQLite database... now I'm happy

[Musashi]

14 hours ago, Joboy2k said:

Im still a little unsure on exactly how Bit calculations work but with these UDF's I can watch them work and hopefully understand them better.

Hint : there are various videos on Youtube that illustrate bit calculations, for example :

https://www.youtube.com/watch?v=-LNUXmMUMAM