BIN$: Difference between revisions

From QB64 Phoenix Edition Wiki
Jump to navigation Jump to search
No edit summary
Tag: Reverted
No edit summary
 
(47 intermediate revisions by the same user not shown)
Line 10: Line 10:
* {{Parameter|number}} can be any [[INTEGER]], [[LONG]] or [[_INTEGER64]] value, positive or negative.
* {{Parameter|number}} can be any [[INTEGER]], [[LONG]] or [[_INTEGER64]] value, positive or negative.
* {{Parameter|number}} can also be any [[SINGLE]], [[DOUBLE]] or [[_FLOAT]] value, but only the integer part of the value is converted in that case. That is, from the value ''-123.45'' the function would convert the ''-123'' only.
* {{Parameter|number}} can also be any [[SINGLE]], [[DOUBLE]] or [[_FLOAT]] value, but only the integer part of the value is converted in that case. That is, from the value ''-123.45'' the function would convert the ''-123'' only.
            ----
 
  kjfn ngke  ----
            ---- jhfgjwe jrehker ----
  kjfn ngke  ---- jfjwe jkhf
  kjfn ngke  ---- jfjwe jkhf ----


{{PageDescription}}
{{PageDescription}}
Line 20: Line 16:
* Different from [[STR$]], this function does not return a leading sign placeholder space, so no [[LTRIM$]] to strip that space from positive numbers is necessary.
* Different from [[STR$]], this function does not return a leading sign placeholder space, so no [[LTRIM$]] to strip that space from positive numbers is necessary.
* [[VAL]] can convert the returned bin string value back to a decimal value by prefixing the string with "[[&B]]".
* [[VAL]] can convert the returned bin string value back to a decimal value by prefixing the string with "[[&B]]".
** Eg. {{InlineCode}}decimal = VAL("&B" + binvalue$){{InlineCodeEnd}}.
** Eg. {{InlineCode}}decimal = {{Cl|VAL}}({{Text|<nowiki>"&B"</nowiki>|#FFB100}} + binvalue$){{InlineCodeEnd}}.




{{PageAvailability}}
{{PageAvailability}}
* '''QB64 2.1 and up''' (QB64 Team)
* '''QB64 v2.1 and up'''
* '''QBPE 0.5 and up''' (QB64 Phoenix Edition)
* '''QB64-PE all versions'''




{{PageExamples}}
{{PageExamples}}
;Example 1: Comparing decimal, hexadecimal, octal and binary string values from 0 to 15.
;Example 1:Comparing decimal, hexadecimal, octal and binary string values from 0 to 15.
{{CodeStart}}
{{CodeStart}}
tabletop$ = " Decimal | Hexadecimal | Octal | Binary "
tabletop$ = {{Text|<nowiki>" Decimal | Hexadecimal | Octal | Binary "</nowiki>|#FFB100}}
tablesep$ = "---------+-------------+-------+--------"
tablesep$ = {{Text|<nowiki>"---------+-------------+-------+--------"</nowiki>|#FFB100}}
tableout$ = "  \ \    |      \\    |  \\  |  \  \  " 'the PRINT USING template
tableout$ = {{Text|<nowiki>"  \ \    |      \\    |  \\  |  \  \  "</nowiki>|#FFB100}} {{Text|<nowiki>'the PRINT USING template</nowiki>|#919191}}


{{Cl|LOCATE}} 2, 10: {{Cl|PRINT}} tabletop$
{{Cl|LOCATE}} {{Text|2|#F580B1}}, {{Text|10|#F580B1}}: {{Cl|PRINT}} tabletop$
{{Cl|LOCATE}} 3, 10: {{Cl|PRINT}} tablesep$
{{Cl|LOCATE}} {{Text|3|#F580B1}}, {{Text|10|#F580B1}}: {{Cl|PRINT}} tablesep$
{{Cl|FOR...NEXT|FOR}} n% = 0 {{Cl|TO}} 15
{{Cl|FOR}} n% = {{Text|0|#F580B1}} {{Cl|TO}} {{Text|15|#F580B1}}
     {{Cl|LOCATE}} 4 + n%, 10: {{Cl|PRINT USING}} tableout$; {{Cl|STR$}}(n%); {{Cl|HEX$}}(n%); {{Cl|OCT$}}(n%); {{Cl|_BIN$}}(n%)
     {{Cl|LOCATE}} {{Text|4|#F580B1}} + n%, {{Text|10|#F580B1}}: {{Cl|PRINT USING}} tableout$; {{Cl|STR$}}(n%); {{Cl|HEX$}}(n%); {{Cl|OCT$}}(n%); {{Cl|_BIN$}}(n%)
{{Cl|NEXT}} n%
{{Cl|NEXT}} n%
{{CodeEnd}}
{{CodeEnd}}
Line 66: Line 62:
;Example 2:Converting a binary value to decimal.
;Example 2:Converting a binary value to decimal.
{{CodeStart}}
{{CodeStart}}
binvalue$ = {{Cl|_BIN$}}(255)
binvalue$ = {{Cl|_BIN$}}({{Text|255|#F580B1}})
{{Cl|PRINT}} "Bin: "; binvalue$
{{Cl|PRINT}} {{Text|<nowiki>"Bin: "</nowiki>|#FFB100}}; binvalue$
{{Cl|PRINT}} "Converting Bin value to Decimal:"; {{Cl|VAL}}("&B" + binvalue$)
{{Cl|PRINT}} {{Text|<nowiki>"Converting Bin value to Decimal:"</nowiki>|#FFB100}}; {{Cl|VAL}}({{Text|<nowiki>"&B"</nowiki>|#FFB100}} + binvalue$)
{{CodeEnd}}
{{CodeEnd}}
{{OutputStart}}
{{OutputStart}}
Line 77: Line 73:


{{PageSeeAlso}}
{{PageSeeAlso}}
* [[HEX$]], [[OCT$]], [[STR$]], [[VAL]]
* [[HEX$]], [[OCT$]], [[STR$]]
* [[&B]] {{text|(binary)}}, [[&H]] {{text|(hexadecimal)}}, [[&O]] {{text|(octal)}}
* [[&B]] (binary), [[&H]] (hexadecimal), [[&O]] (octal), [[VAL]]
* [[Base Comparisons]]
* [[Base Comparisons]]




{{PageNavigation}}
{{PageNavigation}}

Latest revision as of 16:52, 19 March 2023

This function returns the binary (base 2) representation of any numeric value.


Syntax

binvalue$ = _BIN$(number)


Parameters

  • number can be any INTEGER, LONG or _INTEGER64 value, positive or negative.
  • number can also be any SINGLE, DOUBLE or _FLOAT value, but only the integer part of the value is converted in that case. That is, from the value -123.45 the function would convert the -123 only.


Description

  • The function returns the base 2 (binary) representation of the given number as STRING.
  • Different from STR$, this function does not return a leading sign placeholder space, so no LTRIM$ to strip that space from positive numbers is necessary.
  • VAL can convert the returned bin string value back to a decimal value by prefixing the string with "&B".
    • Eg. decimal = VAL("&B" + binvalue$).


Availability

  • QB64 v2.1 and up
  • QB64-PE all versions


Examples

Example 1
Comparing decimal, hexadecimal, octal and binary string values from 0 to 15.
tabletop$ = " Decimal | Hexadecimal | Octal | Binary "
tablesep$ = "---------+-------------+-------+--------"
tableout$ = "  \ \    |      \\     |   \\  |  \  \  " 'the PRINT USING template

LOCATE 2, 10: PRINT tabletop$
LOCATE 3, 10: PRINT tablesep$
FOR n% = 0 TO 15
    LOCATE 4 + n%, 10: PRINT USING tableout$; STR$(n%); HEX$(n%); OCT$(n%); _BIN$(n%)
NEXT n%
Note
Although the decimal numbers 0-15 have a maximum width of 2 digits only, an extra space in the tableout$ template is needed when using the (fixed width string) slash output format, as STR$ values contain a leading sign placeholder space.
          Decimal | Hexadecimal | Octal | Binary
         ---------+-------------+-------+--------
            0     |      0      |   0   |  0
            1     |      1      |   1   |  1
            2     |      2      |   2   |  10
            3     |      3      |   3   |  11
            4     |      4      |   4   |  100
            5     |      5      |   5   |  101
            6     |      6      |   6   |  110
            7     |      7      |   7   |  111
            8     |      8      |   10  |  1000
            9     |      9      |   11  |  1001
            10    |      A      |   12  |  1010
            11    |      B      |   13  |  1011
            12    |      C      |   14  |  1100
            13    |      D      |   15  |  1101
            14    |      E      |   16  |  1110
            15    |      F      |   17  |  1111


Example 2
Converting a binary value to decimal.
binvalue$ = _BIN$(255)
PRINT "Bin: "; binvalue$
PRINT "Converting Bin value to Decimal:"; VAL("&B" + binvalue$)

Bin: 11111111
Converting Bin value to Decimal: 255


See also


Navigation:
Main Page with Articles and Tutorials
Keyword Reference - Alphabetical
Keyword Reference - By usage
Report a broken link
Retrieved from "https://qb64phoenix.com/qb64wiki/index.php?title=BIN$&oldid=8268"