Difference between revisions of "BIT"
(Created page with 'The _BIT datatype can hold only 0 and -1. If you set the variable to any other number then the least significant bit of that number will be set as the variables number, if the bi…') |
imported>Odin |
||
(75 intermediate revisions by 6 users not shown) | |||
Line 1: | Line 1: | ||
− | The _BIT datatype can | + | {{DISPLAYTITLE:_BIT}} |
+ | The [[_BIT]] datatype can return only values of 0 (bit off) and -1 (bit on). | ||
− | + | {{PageSyntax}} | |
+ | : [[DIM]] {{Parameter|variable}} [[AS]] [{{KW|_UNSIGNED}}] [[_BIT]] [* {{Parameter|numberofbits}}] | ||
+ | : [[_DEFINE]] {{Parameter|Letter}}[{{Parameter|-Range}}|,...] [[AS]] [{{KW|_UNSIGNED}}] [[_BIT]] [* {{Parameter|numberofbits}}] | ||
− | |||
− | The _BIT datatype can be succesfully used as a | + | {{PageDescription}} |
+ | * An [[_UNSIGNED]] _BIT can hold 0 or 1 instead of 0 and -1, if you set the numberofbits you can hold larger values depending on the number of bits you have set (_BIT * 8 can hold the same values as [[_BYTE]] for example) and the information below is compromised if setting any number of bits other than 1. | ||
+ | * If you set the variable to any other number then the least significant bit of that number will be set as the variables number, if the bit is 1 (on) then the variable will be -1 and if the bit is 0 (off) then the variable will be 0. | ||
+ | *The least significant bit is the last bit on a string of bits (11111) since that bit will only add 1 to the value if set. The most significant bit is the first bit on a string of bits and changes the value more dramatically (significantly) if set on or off. | ||
+ | *The _BIT datatype can be succesfully used as a [[Boolean]] (TRUE or FALSE) and it requires minimal amount of memory (the lowest amount possible actually, one byte can hold 8 bits, if you want to use bits in order to decrease memory usage, use them as arrays as a _BIT variable by itself allocates 4 bytes - DIM bitarray(800) AS _BIT uses 100 bytes). | ||
+ | * '''When a variable has not been assigned or has no type suffix, the value defaults to [[SINGLE]].''' | ||
+ | * '''[[Keywords_currently_not_supported_by_QB64|_BIT is not supported in User Defined TYPES.]]''' Use a [[_BYTE]] and assign up to 8 bit values as shown below. | ||
+ | *'''Suffix Symbols''' The [[_BIT]] type suffix used is below the grave accent (`), usually located under the tilde (~) key (not an apostrophe). Foreign keyboards may not have the ` key. Try Alt+96 in the IDE. | ||
− | '' | + | :You can define a bit on-the-fly by adding a ` after the variable, like this: {{InlineCode}}variable` = -1{{InlineCodeEnd}} |
+ | |||
+ | :If you want an unsigned bit you can define it on-the-fly by adding ~` instead, like this: {{InlineCode}}variable~` = 1{{InlineCodeEnd}} | ||
+ | |||
+ | :You can set the number of bits on the fly by just adding that number - this defines it as being two bits: {{InlineCode}}variable`2 = -1{{InlineCodeEnd}} | ||
+ | |||
+ | |||
+ | <center>'''[[_BIT|BITS]]'''</center> | ||
+ | * The '''MSB''' is the most significant(largest) bit value and '''LSB''' is the least significant bit of a binary or register memory address value. The order in which the bits are read determines the binary or decimal byte value. There are two common ways to read a byte: | ||
+ | |||
+ | :* '''"Big-endian"''': MSB is the first bit encountered, decreasing to the LSB as the last bit by position, memory address or time. | ||
+ | :* '''"Little-endian"''': LSB is the first bit encountered, increasing to the MSB as the last bit by position, memory address or time. | ||
+ | {{WhiteStart}} | ||
+ | '''Offset or Position: 0 1 2 3 4 5 6 7 Example: 11110000''' | ||
+ | ---------------------------------- -------- | ||
+ | '''Big-Endian Bit On Value:''' 128 64 32 16 8 4 2 1 240 | ||
+ | '''Little-Endian Bit On Value:''' 1 2 4 8 16 32 64 128 15 | ||
+ | {{WhiteEnd}} | ||
+ | ::The big-endian method compares exponents of 2 <sup>7</sup> down to 2 <sup>0</sup> while the little-endian method does the opposite. | ||
+ | |||
+ | <center>'''[[_BYTE|BYTES]]'''</center> | ||
+ | * [[INTEGER]] values consist of 2 bytes called the '''HI''' and '''LO''' bytes. Anytime that the number of binary digits is a multiple of 16 (2bytes, 4 bytes, etc.) and the HI byte's MSB is on(1), the value returned will be negative. Even with [[SINGLE]] or [[DOUBLE]] values! | ||
+ | {{WhiteStart}} '''16 BIT INTEGER OR REGISTER''' | ||
+ | '''AH (High Byte Bits) AL (Low Byte Bits)''' | ||
+ | BIT: 15 14 13 12 11 10 9 8 | 7 6 5 4 3 2 1 0 | ||
+ | ---------------------------------------|-------------------------------------- | ||
+ | HEX: 8000 4000 2000 1000 800 400 200 100 | 80 40 20 10 8 4 2 1 | ||
+ | | | ||
+ | DEC: -32768 16384 8192 4096 2048 1024 512 256 | 128 64 32 16 8 4 2 1 | ||
+ | {{WhiteEnd}} | ||
+ | ::The HI byte's '''MSB''' is often called the '''sign''' bit! When all 16 of the integer binary bits are on, the decimal return is -1. | ||
+ | |||
+ | |||
+ | {{PageExamples}} | ||
+ | ''Example:'' Shifting bits in a value in QB64 versions prior to 1.3 (you can use [[_SHL]] and [[_SHR]] starting with version 1.3). | ||
+ | {{CodeStart}} '' '' | ||
+ | n = 24 | ||
+ | Shift = 3 | ||
+ | |||
+ | {{Cl|PRINT}} LShift(n, Shift) | ||
+ | {{Cl|PRINT}} RShift(n, Shift) | ||
+ | {{Cl|END}} | ||
+ | |||
+ | {{Cl|FUNCTION}} LShift&(n AS {{Cl|LONG}}, LS AS {{Cl|LONG}}) | ||
+ | IF LS < 0 THEN {{Cl|EXIT FUNCTION}} | ||
+ | LShift = {{Cl|INT}}(n * (2 ^ LS)) | ||
+ | {{Cl|END FUNCTION}} | ||
+ | |||
+ | {{Cl|FUNCTION}} RShift&(n AS {{Cl|LONG}}, RS AS {{Cl|LONG}}) | ||
+ | IF RS < 0 THEN {{Cl|EXIT FUNCTION}} | ||
+ | RShift = {{Cl|INT}}(n / (2 ^ RS)) | ||
+ | {{Cl|END FUNCTION}} '' '' | ||
+ | {{CodeEnd}} | ||
+ | {{small|Adapted from code by RThorpe}} | ||
+ | {{OutputStart}} 192 | ||
+ | 3 | ||
+ | {{OutputEnd}} | ||
+ | |||
+ | |||
+ | {{PageSeeAlso}} | ||
+ | * [[&B]] (binary), [[_BYTE]] | ||
+ | * [[_SHL]], [[_SHR]] | ||
+ | * [[_DEFINE]], [[_UNSIGNED]] | ||
+ | * [[DIM]] | ||
+ | * [[Binary]], [[Boolean]] | ||
+ | * [[Variable Types]] | ||
+ | * [[Converting Bytes to Bits]] | ||
+ | |||
+ | |||
+ | {{PageNavigation}} |
Latest revision as of 14:39, 11 April 2019
The _BIT datatype can return only values of 0 (bit off) and -1 (bit on).
Syntax
Description
- An _UNSIGNED _BIT can hold 0 or 1 instead of 0 and -1, if you set the numberofbits you can hold larger values depending on the number of bits you have set (_BIT * 8 can hold the same values as _BYTE for example) and the information below is compromised if setting any number of bits other than 1.
- If you set the variable to any other number then the least significant bit of that number will be set as the variables number, if the bit is 1 (on) then the variable will be -1 and if the bit is 0 (off) then the variable will be 0.
- The least significant bit is the last bit on a string of bits (11111) since that bit will only add 1 to the value if set. The most significant bit is the first bit on a string of bits and changes the value more dramatically (significantly) if set on or off.
- The _BIT datatype can be succesfully used as a Boolean (TRUE or FALSE) and it requires minimal amount of memory (the lowest amount possible actually, one byte can hold 8 bits, if you want to use bits in order to decrease memory usage, use them as arrays as a _BIT variable by itself allocates 4 bytes - DIM bitarray(800) AS _BIT uses 100 bytes).
- When a variable has not been assigned or has no type suffix, the value defaults to SINGLE.
- _BIT is not supported in User Defined TYPES. Use a _BYTE and assign up to 8 bit values as shown below.
- Suffix Symbols The _BIT type suffix used is below the grave accent (`), usually located under the tilde (~) key (not an apostrophe). Foreign keyboards may not have the ` key. Try Alt+96 in the IDE.
- You can define a bit on-the-fly by adding a ` after the variable, like this: variable` = -1
- If you want an unsigned bit you can define it on-the-fly by adding ~` instead, like this: variable~` = 1
- You can set the number of bits on the fly by just adding that number - this defines it as being two bits: variable`2 = -1
- The MSB is the most significant(largest) bit value and LSB is the least significant bit of a binary or register memory address value. The order in which the bits are read determines the binary or decimal byte value. There are two common ways to read a byte:
- "Big-endian": MSB is the first bit encountered, decreasing to the LSB as the last bit by position, memory address or time.
- "Little-endian": LSB is the first bit encountered, increasing to the MSB as the last bit by position, memory address or time.
Offset or Position: 0 1 2 3 4 5 6 7 Example: 11110000 ---------------------------------- -------- Big-Endian Bit On Value: 128 64 32 16 8 4 2 1 240 Little-Endian Bit On Value: 1 2 4 8 16 32 64 128 15
- The big-endian method compares exponents of 2 ^{7} down to 2 ^{0} while the little-endian method does the opposite.
- INTEGER values consist of 2 bytes called the HI and LO bytes. Anytime that the number of binary digits is a multiple of 16 (2bytes, 4 bytes, etc.) and the HI byte's MSB is on(1), the value returned will be negative. Even with SINGLE or DOUBLE values!
16 BIT INTEGER OR REGISTER AH (High Byte Bits) AL (Low Byte Bits) BIT: 15 14 13 12 11 10 9 8 | 7 6 5 4 3 2 1 0 ---------------------------------------|-------------------------------------- HEX: 8000 4000 2000 1000 800 400 200 100 | 80 40 20 10 8 4 2 1 | DEC: -32768 16384 8192 4096 2048 1024 512 256 | 128 64 32 16 8 4 2 1
- The HI byte's MSB is often called the sign bit! When all 16 of the integer binary bits are on, the decimal return is -1.
Examples
Example: Shifting bits in a value in QB64 versions prior to 1.3 (you can use _SHL and _SHR starting with version 1.3).
n = 24 Shift = 3 PRINT LShift(n, Shift) PRINT RShift(n, Shift) END FUNCTION LShift&(n AS LONG, LS AS LONG) IF LS < 0 THEN EXIT FUNCTION LShift = INT(n * (2 ^ LS)) END FUNCTION FUNCTION RShift&(n AS LONG, RS AS LONG) IF RS < 0 THEN EXIT FUNCTION RShift = INT(n / (2 ^ RS)) END FUNCTION
192 3
See also
- &B (binary), _BYTE
- _SHL, _SHR
- _DEFINE, _UNSIGNED
- DIM
- Binary, Boolean
- Variable Types
- Converting Bytes to Bits