BIN$ math negatives

[bplus]

from RhoSigma

Oh, just see another reply, so here is the answer for that one.

The output looks as intended by me, here an example to show pos./neg. number behavior at the _BYTE barrier:
Code: QB64: [Select]
'  128 =         10000000 (8 unsigned data bits)
'  127 =          1111111 (7 unsigned data bits)
' -127 =         10000001 (  normal sign + 7 data bits)
' -128 = 1111111110000000 (extended sign + 7 data bits)
note the sign extension for -128, so it can be distinguished from +128, it's similar at the INTEGER/LONG barriers.

However, if you have better sugestions it should be easy enough to adapt the function.

Nothing better to suggest but maybe a little demo or two to explain.

I learned allot just from looking at this sequence (see attached):

Code: QB64: [Select]

1. _TITLE "Quick BIN$ test" 'b+ 2020-03-02  QB64 v1.4 < important for testing &B numbers
2.  
3. DO
4.     INPUT "Enter a number to convert to test BIN$ > ", test&&
5.     PRINT BIN$(test&&)
6. LOOP UNTIL test&& = 0
7.  
8.  
9. 'Function:  Convert any given dec/hex/oct number into a binary string.
10. '           Can handle positive and negative values and works in that
11. '           similar to the QB64 built-in HEX$ and OCT$ functions.
12. '
13. 'Synopsis:  binary$ = BIN$ (value&&)
14. '
15. 'Result:    binary$ --> The binary representation string of the given
16. '                       number without leading zeros for positive values
17. '                       and either 8/16/32 or 64 chars for negatives,
18. '                       depending on the input size.
19. '
20. 'Inputs:    value&& --> The pos./neg. number to convert, may also be
21. '                       given as &H or &O prefixed value.
22. '
23. 'Notes:     You may also pass in floating point values, as long as its
24. '           represented value fits into the _INTEGER64 (&&) input, hence
25. '           approx. -9.223372036854776E+18 to 9.223372036854776E+18.
26. '           Different from HEX$ and OCT$, BIN$ won't throw an overflow
27. '           error, if this range is exceeded, but the result is probably
28. '           wrong in such a case.
29. '---------------------------------------------------------------------
30. FUNCTION BIN$ (value&&)
31.     '--- option _explicit requirements ---
32.     DIM temp~&&, charPos%, highPos%
33.     '--- init ---
34.     temp~&& = value&&
35.     BIN$ = STRING$(64, "0"): charPos% = 64: highPos% = 64
36.     '--- convert ---
37.     DO
38.         IF (temp~&& AND 1) THEN MID$(BIN$, charPos%, 1) = "1": highPos% = charPos%
39.         charPos% = charPos% - 1: temp~&& = temp~&& \ 2
40.     LOOP UNTIL temp~&& = 0
41.     '--- adjust negative size ---
42.     IF value&& < 0 THEN
43.         IF -value&& < &H0080000000~&& THEN highPos% = 33
44.         IF -value&& < &H0000008000~&& THEN highPos% = 49
45.         IF -value&& < &H0000000080~&& THEN highPos% = 57
46.     END IF
47.     '--- set result ---
48.     BIN$ = MID$(BIN$, highPos%)
49. END FUNCTION
50.  
51.  

[RhoSigma]

Yes, this small sequence shows very good what's basically the difference between positive and negative numbers in binary integer logic.

It's the binary complement, also known as - NOT -

NOT 0 = -1    (&B00000000 (&H00) --> &B11111111 (&HFF))
NOT 1 = -2    (&B00000001 (&H01) --> &B11111110 (&HFE))
NOT 2 = -3    (&B00000010 (&H02) --> &B11111101 (&HFD))
NOT 3 = -4    (&B00000011 (&H03) --> &B11111100 (&HFC))
.
.
.
NOT n = -(n+1)

And the gap of (1) between pos./neg. is because in negative numbers one bit is "stolen" from our max. type range to hold the sign and it's the reason why all programming languages have a extra function to negate a value whithout causing the gap. In most high level languages, such as QB64, this function is a simple preceeding minus (-), in other languages, assembler for instance, we have a extra NEG instruction for that purpose.

What many beginners often misinterpret/misunderstand is, that NEG and NOT are two complete different operations, although they have a very similar effect internally.