A million dollar accountant's headache

[OldMoses]

Since, as far as I know, a USING clause is not available to _PRINTSTRING, I wanted to come up with a quick way to align numbers along their decimal columns. So I came up with the following function (with a test bed display)

It's largely based upon example #1 from the wiki
https://wiki.qb64.org/wiki/LOG

Code: QB64: [Select]

1. 'LogBack% function test bed for _printstring command
2. SCREEN _NEWIMAGE(600, 600, 32)
3. dpos% = 400 'we'll line up our decimal points at x=400
4.  
5. 'ledger lines
6. FOR ln% = -7 TO 7
7.     c& = &H7F7F7F7F * (ln% = 0) - &H3F7F007F * (ln% <> 0)
8.     LINE (400 + (ln% * 8), 0)-(400 + (ln% * 8), _HEIGHT - 1), c& '&H7F7F7F7F
9. NEXT ln%
10.  
11. 'print the number list in columnar fashion
12. _PRINTMODE _KEEPBACKGROUND
13. FOR y% = 1 TO 20
14.     READ a##
15.     _PRINTSTRING (0, y% * 16), "y position=" + STR$(LogBack%(dpos%, a##))
16.     _PRINTSTRING (LogBack%(dpos%, a##), y% * 16), _TRIM$(STR$(a##))
17. NEXT y%
18. END
19.  
20. DATA -1000000.0001,-1000000,-999999.999,-999999,-10000,-1000,-50,-10,-5.678,-1,0
21. DATA 1,4.912,23,99.999,4587.23,12000,999999,1000000,1000001
22.  
23.  
24. '²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²
25. FUNCTION LogBack% (decpos AS INTEGER, value AS _FLOAT)
26.  
27.     'compute position setback to align (value) decimal points at (decpos)
28.     IF ABS(value) >= 1 THEN '           back up 8 pixels / decimal place
29.         LogBack% = decpos - _SHL(INT(LOG(value * SGN(value)) / LOG(10.#)) + 1 - (value < 0), 3)
30.     ELSE '                              a fractional value
31.         IF SGN(value) > 0 THEN
32.             LogBack% = decpos '         start at the decimal place for positive decimal
33.         ELSE
34.             LogBack% = decpos - 8 '     start 8 pixels behind for zero & negative decimals
35.         END IF
36.     END IF
37.  
38. END FUNCTION 'LogBack%
39.  

OK, so far so good, but what's the deal with the 1,000,000 value?

Is it something wrong with my algorithm? A QB64 bug? or just the vicissitudes of binary to decimal math?

I haven't yet found any other values that do this.

[bplus]

Heh! Whew! I'd do it this way:

Code: QB64: [Select]

1. Screen _NewImage(600, 600, 32)
2. dpos% = 400 'we'll line up our decimal points at x=400
3.  
4. 'ledger lines
5. For ln% = -7 To 7
6.     c& = &H7F7F7F7F * (ln% = 0) - &H3F7F007F * (ln% <> 0)
7.     Line (400 + (ln% * 8), 0)-(400 + (ln% * 8), _Height - 1), c& '&H7F7F7F7F
8. Next ln%
9.  
10. 'print the number list in columnar fashion
11. _PrintMode _KeepBackground
12. For y% = 1 To 20
13.     Read a$
14.     dot = InStr(a$, ".")
15.     If dot Then
16.         back = Len(a$) - (Len(a$) - dot + 1)
17.     Else
18.         back = Len(a$)
19.     End If
20.     _PrintString (400 - back * 8, 16 * (y% - 1)), a$
21. Next y%
22. End
23.  
24. Data -1000000.0001,-1000000,-999999.999,-999999,-10000,-1000,-50,-10,-5.678,-1,0
25. Data 1,4.912,23,99.999,4587.23,12000,999999,1000000,1000001
26.  

 [ You are not allowed to view this attachment ]  

[OldMoses]

That certainly gets around the problem and could still be sub'ed out and a string converstion added in the sub. Cool.

The LOG function worked very well for some dynamically resizing grid work I've done, but it's probably not exact enough for what I'm trying to accomplish here. I tried an ascending 10 power loop and it had a hitch at 1000 too, not just 1M.

Code: QB64: [Select]

1. x## = 1
2. DO
3.     x## = x## * 10
4.     LOCATE , 1
5.     PRINT x##;
6.     LOCATE , 20
7.     PRINT INT(LOG(x##) / LOG(10.#))
8. LOOP UNTIL x## = 10000000
9.  

[bplus]

That certainly gets around the problem and could still be sub'ed out and a string converstion added in the sub. Cool.

The LOG function worked very well for some dynamically resizing grid work I've done, but it's probably not exact enough for what I'm trying to accomplish here. I tried an ascending 10 power loop and it had a hitch at 1000 too, not just 1M.

Code: QB64: [Select]

1. x## = 1
2. DO
3.     x## = x## * 10
4.     LOCATE , 1
5.     PRINT x##;
6.     LOCATE , 20
7.     PRINT INT(LOG(x##) / LOG(10.#))
8. LOOP UNTIL x## = 10000000
9.  

Ha! that works fine without Int()

Code: QB64: [Select]

1. x## = 1
2. Do
3.     x## = x## * 10
4.     Locate , 1
5.     Print x##;
6.     Locate , 20
7.     Print Log(x##) / Log(10.#)
8. Loop Until x## = 10000000
9.  

[OldMoses]

I think I added INT because I was having some issues with positioning and it subsequently screwed up every third power of ten. I can't see why, but there it is...

When using it in my grid work, I didn't have INT in the mix.

So I put your string solution in, with my syntax scheme, and it crunched down to even tighter code and functioned flawlessly. Amazing stuff. Thanks.

Code: QB64: [Select]

1. 'LogBack% function test bed for _printstring command
2. SCREEN _NEWIMAGE(600, 600, 32)
3. dpos% = 400 'we'll line up our decimal points at x=400
4.  
5. 'ledger lines
6. FOR ln% = -7 TO 7
7.     c& = &H7F7F7F7F * (ln% = 0) - &H3F7F007F * (ln% <> 0)
8.     LINE (400 + (ln% * 8), 0)-(400 + (ln% * 8), _HEIGHT - 1), c& '&H7F7F7F7F
9. NEXT ln%
10.  
11. 'print the number list in columnar fashion
12. _PRINTMODE _KEEPBACKGROUND
13. FOR y% = 1 TO 20
14.     READ a##
15.     _PRINTSTRING (0, y% * 16), "y position=" + STR$(LogBackII%(dpos%, a##))
16.     _PRINTSTRING (LogBackII%(dpos%, a##), y% * 16), _TRIM$(STR$(a##))
17. NEXT y%
18. END
19.  
20. DATA -1000000.0001,-1000000,-999999.999,-999999,-10000,-1000,-50,-10,-5.678,-1,0
21. DATA 1,4.912,23,99.999,1000,12000,999999,1000000,1000001
22.  
23.  
24. '²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²
25. FUNCTION LogBackII% (decpos AS INTEGER, value AS _FLOAT)
26.  
27.     'featuring Bplus' string fix
28.     a$ = _TRIM$(STR$(value))
29.     dot = INSTR(a$, ".")
30.     LogBackII% = decpos - _SHL(LEN(a$) + (LEN(a$) - dot + 1) * (dot <> 0), 3)
31.  
32. END FUNCTION 'LogBackII%
33.  

[Galleon]

A workaround for _PRINTSTRING-ing a PRINT USING (no doubt others have shared similar things in the past)

Code: QB64: [Select]

1. DIM SHARED printUsing_backBuffer AS LONG
2. DIM SHARED printUsing_sourceBackup AS LONG
3. DIM SHARED printUsing_destBackup AS LONG
4.  
5. SCREEN _NEWIMAGE(800, 600, 32)
6.  
7. DO
8.  
9.     first$ = "Bobby": last$ = "Smith"
10.     boxes% = 1510: sales! = 4530
11.     tmp$ = "Salesperson: & &  #####,.   $$#####,.##"
12.  
13.     COLOR _RGB(RND * 255, RND * 255, RND * 255)
14.  
15.     PrintUsingInit
16.     PRINT USING tmp$; first$; last$; boxes%; sales!
17.     _PRINTSTRING (RND * 800 - 200, RND * 600), PrintUsingResult
18.  
19.     _LIMIT 10
20. LOOP
21.  
22. SUB PrintUsingInit
23.     printUsing_sourceBackup = _SOURCE
24.     printUsing_destBackup = _DEST
25.     IF printUsing_backBuffer = 0 THEN printUsing_backBuffer = _NEWIMAGE(1000, 3, 0)
26.     _DEST printUsing_backBuffer
27.     _SOURCE printUsing_backBuffer
28.     CLS , 1
29. END SUB
30.  
31. FUNCTION PrintUsingResult$
32.     DIM result AS STRING
33.     DIM i AS LONG
34.     FOR i = 1 TO 1000
35.         IF SCREEN(1, i, 1) = 23 THEN EXIT FOR
36.         result = result + CHR$(SCREEN(1, i))
37.     NEXT
38.     PrintUsingResult = result
39.     _DEST printUsing_destBackup
40.     _SOURCE printUsing_sourceBackup
41. END FUNCTION
42.  

[SMcNeill]

Since everyone is tossing in their solution to this type problem, I thought I'd add in mine:

Code: QB64: [Select]

1. 'LogBack% function test bed for _printstring command
2. Screen _NewImage(600, 600, 32)
3. dpos% = 400 'we'll line up our decimal points at x=400
4.  
5. 'ledger lines
6. For ln% = -7 To 7
7.     c& = &H7F7F7F7F * (ln% = 0) - &H3F7F007F * (ln% <> 0)
8.     Line (400 + (ln% * 8), 0)-(400 + (ln% * 8), _Height - 1), c& '&H7F7F7F7F
9. Next ln%
10.  
11. 'print the number list in columnar fashion
12. _PrintMode _KeepBackground
13. For y% = 1 To 20
14.     Read a##
15.     a$ = formatMoney(a##, 4) 'a max of 4 decimal places for my money
16.     _PrintString (437 - _PrintWidth(a$), 16 * (y% - 1)), a$
17. Next y%
18. End
19.  
20. Data -1000000.0001,-1000000,-999999.999,-999999,-10000,-1000,-50,-10,-5.678,-1,0
21. Data 1,4.912,23,99.999,4587.23,12000,999999,1000000,1000001
22.  
23.  
24. Function formatMoney$ (money##, maxLength)
25.     m$ = Str$(money##)
26.     d = (Len(m$) - _InStrRev(m$, ".")) Mod Len(m$)
27.     If d = 0 Then m$ = m$ + "." 'add a decimal if none exists
28.     formatMoney$ = m$ + String$(maxLength - d, "0") 'add the necessary number of periods
29. End Function
30.  

Since this is a "million dollar accountant's" problem, I thought it might be best to simply add in the sufficient number of zeros to the end of the money.  Personally, nothing gets me as distracted when working with numbers, as trying to sort out which figures go with which column or row, and misaligned formatting is one of those things that has my OCD twitching constantly.  Even though there's nothing in the world wrong with everyone else's solution, somehow I find my mind and attention always being drawn to that lone -5.678 which has numbers hanging off to the right side there, with none of the other values around it having any.

With everything displaying their zeroes properly, nothing stands out as taking precedence on the right side of the line, which makes it easier to find and focus on the truly important things -- which stands out the most on the left side of the line.  (Also known as. "What's the greatest expense and greatest source of income!")

Maybe it's just me, but I'd rather have those trailing zeroes when dealing with accountant stuff, rather than not have them.  ;)

[tomxp411]

All this really highlights how terrible IEEE-754 floats actually are for representing decimal values. While they're perfectly fine for values that don't need to be printed, but any time you're dealing with money or with explicit powers of 10 (ie decimal positions), it's better to use integer types and deal with the decimal yourself.

When I worked in the banking industry, we always stored values as integers. We had a special "print money" function to convert integers to dollars and cents, then print that. It went something like this:

Code: QB64: [Select]

1. DEFLNG A-Z
2.  
3. PrintDec 1
4. PrintDec 10
5. PrintDec 100
6. PrintDec 1000
7. PrintDec 10000
8. PrintDec 100000
9. PrintDec 1000000
10. PrintDec 10000000
11. PrintDec 100000000
12. PrintDec -1
13. PrintDec -10
14. PrintDec -100
15. PrintDec -10000000
16. PrintDec 12350
17. PrintDec -12350
18.  
19. SUB PrintDec (N AS LONG)
20.     M$ = _TRIM$(STR$(ABS(N)))
21.     IF LEN(M$) < 2 THEN M$ = "00" + M$
22.     IF LEN(M$) < 3 THEN M$ = "0" + M$
23.  
24.     lm = LEN(M$)
25.     N$ = " "
26.     IF N < 0 THEN N$ = "-"
27.     PRINT SPACE$(10 - lm); N$; LEFT$(M$, lm - 2); "."; RIGHT$(M$, 2)
28. END SUB
29.