String Math

[bplus]

Well I know Pete started a thread on this subject but started on wrong foot maybe, doing 1 character at a time.
https://www.qb64.org/forum/index.php?topic=1093.0

Anyway I thought I take another shot at it with more than 1 character at a time...
Here is the easiest first step adding 2 integers, no checks on the strings yet for - signs or non numbers.

Add$(a$, b$) with tester code:

Code: QB64: [Select]

1. _TITLE "String Math" 'b+ started 2020-08-14
2. ' 2020-08-14 start with add 2 arbitrary long strings
3. RANDOMIZE TIMER 'now that it's seems to be running silent
4. ' special or hard cases found while testing
5. PRINT add$("0", "0") ' just 1 0?
6. PRINT add$("1", "10023") 'fixed
7. PRINT add$(STRING$(19, "9"), "1"), LEN(add$(STRING$(19, "9"), "1")) ' 1 and 19 0's
8. PRINT add$("980", "401374340") 'fixed
9.  
10. 'random testing
11. DIM al AS LONG, bl AS LONG, sum AS _INTEGER64, e1 AS INTEGER, e2 AS INTEGER
12. DO
13.     'pick two numbers
14.     e1 = INT(10 * RND): e2 = INT(10 * RND)
15.     al = RND * 10 ^ e1: bl = RND * 10 ^ e2: sum = al + bl
16.     a$ = _TRIM$(STR$(al)): b$ = _TRIM$(STR$(bl))
17.     PRINT
18.     PRINT a$; " plus "; b$; " ="
19.     addStr$ = add$(a$, b$)
20.     PRINT addStr$; " according to add function we are testing."
21.     qbCalc$ = _TRIM$(STR$(sum))
22.     PRINT qbCalc$; " according to QB64 math"
23.     IF qbCalc$ <> addStr$ THEN BEEP: SLEEP ' <<<<<<<<<< stop when find an discrepency
24.     PRINT "Next sum check in 10 secs, or press key,  press escape to quit..."
25.     _LIMIT 100 ' OK running silent so speed up
26. LOOP UNTIL _KEYDOWN(27)
27.  
28. FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
29.     'first thing is to set a and b numbers to same length and multiple of 8 so can take 8 digits at a time
30.     DIM la AS INTEGER, bl AS INTEGER, m AS INTEGER, g AS INTEGER, sa AS LONG, sb AS LONG, co AS LONG
31.     DIM t$, new$, result$
32.     la = LEN(a$): lb = LEN(b$)
33.     IF la > lb THEN m = INT(la / 8) + 1 ELSE m = INT(lb / 8) + 1
34.     fa$ = RIGHT$(STRING$(m * 8, "0") + a$, m * 8)
35.     fb$ = RIGHT$(STRING$(m * 8, "0") + b$, m * 8)
36.  
37.     'now taking 4 digits at a time From Steve I learned we can do more than 1 digit at a time
38.     FOR g = 1 TO m
39.         sa = VAL(MID$(fa$, m * 8 - g * 8 + 1, 8))
40.         sb = VAL(MID$(fb$, m * 8 - g * 8 + 1, 8))
41.         t$ = RIGHT$(STRING$(16, "0") + _TRIM$(STR$(sa + sb + co)), 16)
42.         co = VAL(MID$(t$, 1, 8))
43.         new$ = MID$(t$, 9)
44.         result$ = new$ + result$
45.  
46.         'debug
47.         'PRINT m * 8, sa, sb, t$, co, result$
48.         'INPUT "OK "; w$ 'OK
49.     NEXT
50.  
51.     IF co THEN result$ = STR$(co) + result$
52.     result$ = _TRIM$(result$)
53.     'strip 0
54.     i = 1: find = 0
55.     WHILE i < LEN(result$) AND MID$(result$, i, 1) = "0"
56.         i = i + 1: find = 1
57.     WEND
58.     IF find = 1 THEN result$ = MID$(result$, i)
59.     add$ = result$
60. END FUNCTION

It's running silent so it's not finding problems (anymore) ;-))

EDIT: I did this for INTEGERS first taking 4 at a time then switched to LONG taking 8 at a time.

[SMcNeill]

Easiest way to do this is with _UNSIGNED_INTEGER64 values, so you can read and work with 18 digits at a time.

For example:

1234567890.9078563412 is the same as 000000001234567890.907856341200000000.  <-- This scaled our string to a limit of digits so we can work with it in two chunks (left side of decimal once, right side of decimal once).

It's a ton faster than reading and adding a single digit at a time.

(Greater precision should be processed in batches of 18, then reduced to set limit, as desired.)

I'm occupied here taking care of mom for the next few days, but if you need me to write a quick demo, I'll do it when I get back home after.  ;)


Unsigned int64 is 18,446,744,073,709,551,615, which gives you room to add two 18-digit values together and have the 19th digit for the carry-over.

[bplus]

Easiest way to do this is with _UNSIGNED_INTEGER64 values, so you can read and work with 18 digits at a time.

For example:

1234567890.9078563412 is the same as 000000001234567890.907856341200000000.  <-- This scaled our string to a limit of digits so we can work with it in two chunks (left side of decimal once, right side of decimal once).

It's a ton faster than reading and adding a single digit at a time.

(Greater precision should be processed in batches of 18, then reduced to set limit, as desired.)

I'm occupied here taking care of mom for the next few days, but if you need me to write a quick demo, I'll do it when I get back home after.  ;)


Unsigned int64 is 18,446,744,073,709,551,615, which gives you room to add two 18-digit values together and have the 19th digit for the carry-over.

Nice idea but VAL() fails us for 18 or even 16 digits.

Code: QB64: [Select]

1. _TITLE "VAL Limit"
2. DIM a AS _UNSIGNED LONG
3. FOR i = 1 TO 20
4.     PRINT i, VAL(STRING$(i, "9"))
5. NEXT
6.  
7.  

OK will try 14 places but it's that 14-16 digits thing again, no, I feel safer with 12 places at a time.

[bplus]

Oh hell I had it right the first time, VAL() only gives us 9 digits when assigning to a variable!?!?

Code: QB64: [Select]

1. _TITLE "VAL Limit"
2. DIM a AS _UNSIGNED LONG, b AS LONG
3. FOR i = 1 TO 20
4.     a = VAL(STRING$(i, "9"))
5.     b = VAL(STRING$(i, "9"))
6.     PRINT i, a, b, VAL(STRING$(i, "9"))
7. NEXT
8.  

9 Digits is the limit? Is this a bug?

[SMcNeill]

Oh hell I had it right the first time, VAL() only gives us 9 digits when assigning to a variable!?!?

Code: QB64: [Select]

1. _TITLE "VAL Limit"
2. DIM a AS _UNSIGNED LONG, b AS LONG
3. FOR i = 1 TO 20
4.     a = VAL(STRING$(i, "9"))
5.     b = VAL(STRING$(i, "9"))
6.     PRINT i, a, b, VAL(STRING$(i, "9"))
7. NEXT
8.  

9 Digits is the limit? Is this a bug?

No bug.  https://www.qb64.org/wiki/Data_types

DIM a AS _UNSIGNED LONG, b AS LONG

Use _INTEGER64, not LONG

[bplus]

No bug.  https://www.qb64.org/wiki/Data_types

DIM a AS _UNSIGNED LONG, b AS LONG

Use _INTEGER64, not LONG

Did you run that little code snippet?

I showed that  VAL() wont give an UNSIGNED LONG variable more that 9 digits, repeat only 9 digits!

9 digits is the limit to VAL() assigned variables.

It doesn't seem right, that's why I asked if it is a bug.

 

AT 10 digits VAL() turns the 9's to gook!

[SMcNeill]

It's not a bug.  It's the limits of your data type.

A byte is from 0 to 255.
An integer is from 0 to 65535.
A long is from 0 to 4,294,967,295.  Anything greater than that value overflows.

Does the following glitch out for you?

Code: [Select]

_TITLE "VAL Limit"
DIM a AS _UNSIGNED _INTEGER64, b AS _INTEGER64
FOR i = 1 TO 20
    a = VAL(STRING$(i, "9"))
    b = VAL(STRING$(i, "9"))
    PRINT i, a, b, VAL(STRING$(i, "9"))
NEXT

[bplus]

Oh crap _INTEGER64 dang it! I got the two types mixed up! Sorry.


Ok so 18 digits looks OK but 19 does not:
 

[SMcNeill]

Oh crap _INTEGER64 dang it! I got the two types mixed up! Sorry.

That's why I even posted it in bold and italics for you.  ;D

[bplus]

Sorry again, home life has got me distracted big time.

But I don't know about the carry over 19th digit.

[SMcNeill]

Oh crap _INTEGER64 dang it! I got the two types mixed up! Sorry.


Ok so 18 digits looks OK but 19 does not:
 

Int64 maxes at 9,223,372,036,854,775,807

If you add 999,999,999,999,999,999 to 999,999,999,999,999,999, the total will be less than 9,223,372,036,854,775,807.

19 nines overflows, but 18 nines plus 18 nines won't.

It's why I said work with 18 digits and reserve the 19th for overflow. :)

[bplus]

19 nines overflows, but 18 nines plus 18 nines won't.

I am convinced! very good argument Steve, and it is working with 18 digits at a time:

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. _TITLE "String Math add$ 2020-08-14_9P" 'b+ started 2020-08-14
3. ' 2020-08-14 start with add 2 arbitrary long strings
4. ' 2020-08-14 well it was 9PM when I started  as per Steve switch to _UNSIGNED _INTEGER64
5.  
6. RANDOMIZE TIMER 'now that it's seems to be running silent
7. ' special or hard cases found while testing
8. PRINT add$("0", "0") ' just 1 0?
9. PRINT add$("1", "10023") 'fixed
10.  
11. DIM aa$
12. aa$ = STRING$(19, "9")
13. PRINT "aa$ = "; aa$ ' fine!!
14. PRINT "aa$ + 1 = "; add$(aa$, "1"), "that's "; LEN(add$(aa$, "1")); " long."
15. PRINT "aa$ + aa$ = "; add$(aa$, aa$)
16. PRINT add$("980", "401374340") 'fixed
17. PRINT " press any to for random testing that can be checked..."
18. SLEEP
19.  
20. 'random testing
21. DIM al AS LONG, bl AS LONG, sum AS _INTEGER64, e1 AS INTEGER, e2 AS INTEGER, a$, b$, addStr$, qbCalc$
22. DO
23.     'pick two numbers
24.     e1 = INT(10 * RND): e2 = INT(10 * RND)
25.     al = RND * 10 ^ e1: bl = RND * 10 ^ e2: sum = al + bl
26.     a$ = _TRIM$(STR$(al)): b$ = _TRIM$(STR$(bl))
27.     PRINT
28.     PRINT a$; " plus "; b$; " ="
29.     addStr$ = add$(a$, b$)
30.     PRINT addStr$; " according to add function we are testing."
31.     qbCalc$ = _TRIM$(STR$(sum))
32.     PRINT qbCalc$; " according to QB64 math"
33.     IF qbCalc$ <> addStr$ THEN BEEP: SLEEP ' <<<<<<<<<< stop when find an discrepency
34.     PRINT "Next sum check in 10 secs, or press key,  press escape to quit..."
35.     _LIMIT 100 ' OK running silent so speed up
36. LOOP UNTIL _KEYDOWN(27)
37.  
38. FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
39.     'first thing is to set a and b numbers to same length and multiple of 8 so can take 8 digits at a time
40.     DIM la AS INTEGER, lb AS INTEGER, m AS INTEGER, g AS INTEGER, i AS INTEGER, find AS INTEGER
41.     DIM sa AS _UNSIGNED _INTEGER64, sb AS _UNSIGNED _INTEGER64, co AS _UNSIGNED _INTEGER64
42.     DIM fa$, fb$, t$, new$, result$
43.     la = LEN(a$): lb = LEN(b$)
44.     IF la > lb THEN m = INT(la / 18) + 1 ELSE m = INT(lb / 18) + 1
45.     fa$ = RIGHT$(STRING$(m * 18, "0") + a$, m * 18)
46.     fb$ = RIGHT$(STRING$(m * 18, "0") + b$, m * 18)
47.  
48.     'now taking 4 digits at a time From Steve I learned we can do more than 1 digit at a time
49.     FOR g = 1 TO m
50.         sa = VAL(MID$(fa$, m * 18 - g * 18 + 1, 18))
51.         sb = VAL(MID$(fb$, m * 18 - g * 18 + 1, 18))
52.         t$ = RIGHT$(STRING$(36, "0") + _TRIM$(STR$(sa + sb + co)), 36)
53.         co = VAL(MID$(t$, 1, 18))
54.         new$ = MID$(t$, 19)
55.         result$ = new$ + result$
56.  
57.         'debug
58.         'DIM w$
59.         'PRINT a$, m * 18, sa, sb, t$, co, result$
60.         'INPUT "OK "; w$ 'OK
61.     NEXT
62.  
63.     IF co THEN result$ = STR$(co) + result$
64.     result$ = _TRIM$(result$)
65.     'strip 0
66.     i = 1: find = 0
67.     WHILE i < LEN(result$) AND MID$(result$, i, 1) = "0"
68.         i = i + 1: find = 1
69.     WEND
70.     IF find = 1 THEN result$ = MID$(result$, i)
71.     add$ = result$
72. END FUNCTION
73.  
74.  

Now back to that other distraction Subtraction, it's a little more tricky handling the borrowing.

[SMcNeill]

If you decide to multiply, I think your limit then is 9 digits.  Anything higher may overflow.

Subtraction isn't any real difference from addition, with 18(+1) digits in use.  (Take 19 digits from the larger number, 18 from the smaller, subtract.  Recycle the 19th digit as overflow.  Result has sign of largest number.)

[bplus]

The borrowing had me concerned but I had worked that out in SmallBASIC (doing 1 digit at a time), beautiful use of MID$ SUB not Function! Plus I had to create an 18 0's string _UNSIGNED _INTEGER64*  variable otherwise the math was returning answers with dang E notation.

Here is subst$ function:

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. _TITLE "String Math subtr$" 'b+ started 2020-08-14
3. ' 2020-08-14 start with add 2 arbitrary long strings
4. ' 2020-08-14 add$ posted 5 PM or so
5. ' 2020-08-14 opt explicit, start subtr$ function
6. ' 2020-08-15 1 AM subst$ function looking good!
7.  
8. RANDOMIZE TIMER 'now that it's seems to be running silent
9. ' special or hard cases found while testing
10. PRINT subtr$("0", "0")
11. PRINT subtr$("11111111111111111375", "11111111111111111374")
12. PRINT subtr$("11111111111111111374", "11111111111111111375")
13. PRINT subtr$("1", "10023")
14. PRINT subtr$("1" + STRING$(50, "0"), "1"), LEN(subtr$("1" + STRING$(50, "0"), "1"))
15. PRINT subtr$("980", "5")
16. PRINT subtr$("1" + STRING$(99, "0"), STRING$(99, "9"))
17. PRINT subtr$(STRING$(99, "9"), "1" + STRING$(99, "0"))
18. PRINT "press any for Random testing against QB64 math calculations..."
19. SLEEP
20.  
21. 'random testing
22. DIM al AS LONG, bl AS LONG, sum AS _INTEGER64, e1 AS INTEGER, e2 AS INTEGER, a$, b$, subtrStr$, qbCalc$
23. DO
24.     'pick two numbers
25.     e1 = INT(10 * RND): e2 = INT(10 * RND)
26.     al = RND * 10 ^ e1: bl = RND * 10 ^ e2: sum = al - bl
27.     a$ = _TRIM$(STR$(al)): b$ = _TRIM$(STR$(bl))
28.     PRINT
29.     PRINT a$; " minus "; b$; " ="
30.     subtrStr$ = subtr$(a$, b$)
31.     PRINT subtrStr$; " according to subtr$ function we are testing."
32.     qbCalc$ = _TRIM$(STR$(sum))
33.     PRINT qbCalc$; " according to QB64 math"
34.     IF qbCalc$ <> subtrStr$ THEN BEEP: SLEEP ' <<<<<<<<<< stop when find an discrepency
35.     PRINT "Next sum check in 10 secs, or press key,  press escape to quit..."
36.     SLEEP 10 '
37. LOOP UNTIL _KEYDOWN(27)
38.  
39. FUNCTION subtr$ (sum$, minus$) ' assume both numbers are positive all digits
40.     IF sum$ = minus$ THEN subtr$ = "0": EXIT SUB
41.  
42.     DIM ls AS INTEGER, lm AS INTEGER, m AS INTEGER, g AS INTEGER, i AS INTEGER, find AS INTEGER, p AS INTEGER
43.     DIM VB AS _UNSIGNED _INTEGER64, vs AS _UNSIGNED _INTEGER64, tenE18 AS _UNSIGNED _INTEGER64
44.     DIM sign$, LG$, sm$, t$, new$, result$
45.  
46.     tenE18 = 1000000000000000000 'yes!!! no dang E's
47.     ' which is bigger?
48.     ls = LEN(sum$): lm = LEN(minus$)
49.     IF ls > lm THEN
50.         sign$ = ""
51.         m = INT(ls / 18) + 1
52.         LG$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
53.         sm$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
54.     ELSEIF ls < lm THEN
55.         sign$ = "-"
56.         m = INT(lm / 18) + 1
57.         LG$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
58.         sm$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
59.     ELSEIF ls = lm THEN
60.         FOR i = 1 TO LEN(sum$)
61.             IF VAL(MID$(sum$, i, 1)) > VAL(MID$(minus$, i, 1)) THEN
62.                 sign$ = ""
63.                 m = INT(ls / 8) + 1
64.                 LG$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
65.                 sm$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
66.                 EXIT FOR
67.             ELSEIF VAL(MID$(sum$, i, 1)) < VAL(MID$(minus$, i, 1)) THEN
68.                 sign$ = "-"
69.                 m = INT(lm / 18) + 1
70.                 LG$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
71.                 sm$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
72.                 EXIT FOR
73.             END IF
74.         NEXT
75.     END IF
76.     'now taking 18 digits at a time From Steve I learned we can do more than 1 digit at a time
77.     FOR g = 1 TO m
78.         VB = VAL(MID$(LG$, m * 18 - g * 18 + 1, 18))
79.         vs = VAL(MID$(sm$, m * 18 - g * 18 + 1, 18))
80.         IF vs > VB THEN
81.             t$ = RIGHT$(STRING$(18, "0") + _TRIM$(STR$(tenE18 - vs + VB)), 18)
82.  
83.             'debug
84.             'PRINT VB, tenE18, tenE18 - vs + VB, " t$ = "; t$
85.  
86.             ''borrow 1 = rewrite string
87.             p = (m - g) * 18
88.             WHILE p > 0 AND MID$(LG$, p, 1) = "0"
89.                 MID$(LG$, p, 1) = "9"
90.                 p = p - 1
91.             WEND
92.             IF p > 0 THEN MID$(LG$, p, 1) = _TRIM$(STR$(VAL(MID$(LG$, p, 1)) - 1))
93.         ELSE
94.             t$ = RIGHT$(STRING$(18, "0") + _TRIM$(STR$(VB - vs)), 18)
95.         END IF
96.         result$ = t$ + result$
97.     NEXT
98.     result$ = _TRIM$(result$)
99.     'strip 0
100.     i = 1: find = 0
101.     WHILE i < LEN(result$) AND MID$(result$, i, 1) = "0"
102.         i = i + 1: find = 1
103.     WEND
104.     IF find = 1 THEN result$ = MID$(result$, i)
105.     subtr$ = sign$ + result$
106. END FUNCTION
107.  
108. FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
109.     'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
110.     DIM la AS INTEGER, lb AS INTEGER, m AS INTEGER, g AS INTEGER, i AS INTEGER, find AS INTEGER
111.     DIM sa AS _UNSIGNED _INTEGER64, sb AS _UNSIGNED _INTEGER64, co AS _UNSIGNED _INTEGER64
112.     DIM fa$, fb$, t$, new$, result$
113.     la = LEN(a$): lb = LEN(b$)
114.     IF la > lb THEN m = INT(la / 18) + 1 ELSE m = INT(lb / 18) + 1
115.     fa$ = RIGHT$(STRING$(m * 18, "0") + a$, m * 18)
116.     fb$ = RIGHT$(STRING$(m * 18, "0") + b$, m * 18)
117.  
118.     'now taking 18 digits at a time Thanks Steve McNeill
119.     FOR g = 1 TO m
120.         sa = VAL(MID$(fa$, m * 18 - g * 18 + 1, 18))
121.         sb = VAL(MID$(fb$, m * 18 - g * 18 + 1, 18))
122.         t$ = RIGHT$(STRING$(36, "0") + _TRIM$(STR$(sa + sb + co)), 36)
123.         co = VAL(MID$(t$, 1, 18))
124.         new$ = MID$(t$, 19)
125.         result$ = new$ + result$
126.  
127.         'debug
128.         'DIM w$
129.         'PRINT a$, m * 18, sa, sb, t$, co, result$
130.         'INPUT "OK "; w$ 'OK
131.     NEXT
132.     IF co THEN result$ = STR$(co) + result$
133.     result$ = _TRIM$(result$)
134.     'strip 0
135.     i = 1: find = 0
136.     WHILE i < LEN(result$) AND MID$(result$, i, 1) = "0"
137.         i = i + 1: find = 1
138.     WEND
139.     IF find = 1 THEN result$ = MID$(result$, i)
140.     add$ = result$
141. END FUNCTION
142.  

Thanks Steve for your help tonight, nice to know someone whose been through this is looking over my shoulder.

*EDIT: for some reason my brain is constantly writing _UNSIGNED LONG when I mean to write _UNSIGNED _INTEGER64. Guess I am in habit of using _UNSIGNED LONG for color.

EDIT2: While starting the mult$ function, I noticed I did not update the subst$ test code with the latest add$ function that uses 18 digits at a time. Added a couple more special tests to substr$ function test code.

[bplus]

OK I think I have mult$ function working, can anyone find a test that points to problem?

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. _TITLE "String Math mult$" 'b+ started 2020-08-15 adding to add$() and subtr$()
3. ' 2020-08-14 start with add 2 arbitrary long strings
4. ' 2020-08-14 add$ posted 5 PM or so
5. ' 2020-08-14 opt explicit, start subtr$ function
6. ' 2020-08-15 1 AM subst$ function looking good!
7. ' 2020-08-15 fix some code from previous subs then attempt mult$ sub
8.  
9. RANDOMIZE TIMER 'now that it's seems to be running silent
10. SCREEN _NEWIMAGE(1024, 700, 32)
11. _DELAY .25
12. _SCREENMOVE _MIDDLE
13.  
14. ''test that VAL can do 9 * 18 nines
15. 'DIM a AS _UNSIGNED _INTEGER64, b AS _UNSIGNED _INTEGER64, c AS _UNSIGNED _INTEGER64
16. 'b = 9
17. 'a = VAL(STRING$(18, "9"))
18. 'c = a * b
19. 'PRINT c 'OK
20.  
21. ' special or hard cases found while testing
22. DIM test$
23. PRINT mult$(STRING$(54, "3"), "0") 'OK
24. test$ = mult$(STRING$(54, "3"), "1")
25. PRINT test$, LEN(test$)
26. test$ = mult$(STRING$(54, "3"), "5")
27. PRINT test$, LEN(test$)
28. test$ = mult$(STRING$(54, "3"), "1" + STRING$(50, "0"))
29. PRINT test$, LEN(test$)
30. test$ = mult$(STRING$(50, "9"), STRING$(50, "9")) ' n-1 nines +8 then n-1 zeros + 1 = 2 * n length
31. PRINT test$, LEN(test$)
32. PRINT: PRINT "Press any for Random testing against QB64 calculations..."
33. SLEEP
34.  
35. 'random testing
36. DIM al AS _UNSIGNED _INTEGER64, bl AS _UNSIGNED _INTEGER64
37. DIM product AS _UNSIGNED _INTEGER64, e1 AS INTEGER, e2 AS INTEGER, a$, b$, multStr$, qbCalc$
38. DO
39.     'pick two numbers
40.     e1 = INT(10 * RND): e2 = INT(10 * RND)
41.     al = RND * 10 ^ e1: bl = RND * 10 ^ e2: product = al * bl
42.     a$ = _TRIM$(STR$(al)): b$ = _TRIM$(STR$(bl))
43.     PRINT
44.     PRINT a$; " times "; b$; " ="
45.     multStr$ = mult$(a$, b$)
46.     PRINT multStr$; " according to mult$ function we are testing."
47.     qbCalc$ = _TRIM$(STR$(product))
48.     PRINT qbCalc$; " according to QB64 math"
49.     IF qbCalc$ <> multStr$ THEN BEEP: SLEEP ' <<<<<<<<<< stop when find an discrepency
50.     PRINT "Next sum check in 10 secs, or press key,  press escape to quit..."
51.     SLEEP 10
52. LOOP UNTIL _KEYDOWN(27)
53.  
54. FUNCTION mult$ (a$, b$) 'assume both positive integers prechecked as all digits strings
55.     DIM la AS INTEGER, lb AS INTEGER, m AS INTEGER, g AS INTEGER, i AS INTEGER, find AS INTEGER, dp AS INTEGER
56.     DIM v18 AS _UNSIGNED _INTEGER64, sd AS _UNSIGNED _INTEGER64, co AS _UNSIGNED _INTEGER64
57.     DIM f18$, f1$, t$, build$, accum$
58.  
59.     'find the longer number and make it a mult of 18 to take 18 digits at a time from it
60.     la = LEN(a$): lb = LEN(b$)
61.     IF la > lb THEN
62.         m = INT(la / 18) + 1
63.         f18$ = RIGHT$(STRING$(m * 18, "0") + a$, m * 18)
64.         f1$ = b$
65.     ELSE
66.         m = INT(lb / 18) + 1
67.         f18$ = RIGHT$(STRING$(m * 18, "0") + b$, m * 18)
68.         f1$ = a$
69.     END IF
70.     FOR dp = LEN(f1$) TO 1 STEP -1 'dp = digit position of the f1$
71.         build$ = "" 'line builder
72.         co = 0
73.         'now taking 18 digits at a time Thanks Steve McNeill
74.         FOR g = 1 TO m
75.             v18 = VAL(MID$(f18$, m * 18 - g * 18 + 1, 18))
76.             sd = VAL(MID$(f1$, dp, 1))
77.             t$ = RIGHT$(STRING$(19, "0") + _TRIM$(STR$(v18 * sd + co)), 19)
78.             co = VAL(MID$(t$, 1, 1))
79.             build$ = MID$(t$, 2) + build$
80.         NEXT g
81.         IF co THEN build$ = _TRIM$(STR$(co)) + build$
82.         IF dp = LEN(f1$) THEN
83.             accum$ = build$
84.         ELSE
85.             accum$ = add$(accum$, build$ + STRING$(LEN(f1$) - dp, "0"))
86.         END IF
87.     NEXT dp
88.     'strip 0
89.     i = 1: find = 0
90.     WHILE i < LEN(accum$) AND MID$(accum$, i, 1) = "0"
91.         i = i + 1: find = 1
92.     WEND
93.     IF find = 1 THEN accum$ = MID$(accum$, i)
94.     mult$ = accum$
95. END FUNCTION
96.  
97. FUNCTION subtr$ (sum$, minus$) ' assume both numbers are positive all digits
98.     IF sum$ = minus$ THEN subtr$ = "0": EXIT SUB
99.  
100.     DIM ls AS INTEGER, lm AS INTEGER, m AS INTEGER, g AS INTEGER, i AS INTEGER, find AS INTEGER, p AS INTEGER
101.     DIM VB AS _UNSIGNED _INTEGER64, vs AS _UNSIGNED _INTEGER64, tenE18 AS _UNSIGNED _INTEGER64
102.     DIM sign$, LG$, sm$, t$, result$
103.  
104.     tenE18 = 1000000000000000000 'yes!!! no dang E's
105.     ' which is bigger?
106.     ls = LEN(sum$): lm = LEN(minus$)
107.     IF ls > lm THEN
108.         sign$ = ""
109.         m = INT(ls / 18) + 1
110.         LG$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
111.         sm$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
112.     ELSEIF ls < lm THEN
113.         sign$ = "-"
114.         m = INT(lm / 18) + 1
115.         LG$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
116.         sm$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
117.     ELSEIF ls = lm THEN
118.         FOR i = 1 TO LEN(sum$)
119.             IF VAL(MID$(sum$, i, 1)) > VAL(MID$(minus$, i, 1)) THEN
120.                 sign$ = ""
121.                 m = INT(ls / 8) + 1
122.                 LG$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
123.                 sm$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
124.                 EXIT FOR
125.             ELSEIF VAL(MID$(sum$, i, 1)) < VAL(MID$(minus$, i, 1)) THEN
126.                 sign$ = "-"
127.                 m = INT(lm / 18) + 1
128.                 LG$ = RIGHT$(STRING$(m * 18, "0") + minus$, m * 18)
129.                 sm$ = RIGHT$(STRING$(m * 18, "0") + sum$, m * 18)
130.                 EXIT FOR
131.             END IF
132.         NEXT
133.     END IF
134.     'now taking 18 digits at a time From Steve I learned we can do 18
135.     FOR g = 1 TO m
136.         VB = VAL(MID$(LG$, m * 18 - g * 18 + 1, 18))
137.         vs = VAL(MID$(sm$, m * 18 - g * 18 + 1, 18))
138.         IF vs > VB THEN
139.             t$ = RIGHT$(STRING$(18, "0") + _TRIM$(STR$(tenE18 - vs + VB)), 18)
140.  
141.             'debug
142.             'PRINT VB, tenE18, tenE18 - vs + VB, " t$ = "; t$
143.  
144.             ''borrow 1 = rewrite string
145.             p = (m - g) * 18
146.             WHILE p > 0 AND MID$(LG$, p, 1) = "0"
147.                 MID$(LG$, p, 1) = "9"
148.                 p = p - 1
149.             WEND
150.             IF p > 0 THEN MID$(LG$, p, 1) = _TRIM$(STR$(VAL(MID$(LG$, p, 1)) - 1))
151.         ELSE
152.             t$ = RIGHT$(STRING$(18, "0") + _TRIM$(STR$(VB - vs)), 18)
153.         END IF
154.         result$ = t$ + result$
155.     NEXT
156.     result$ = _TRIM$(result$)
157.     'strip 0
158.     i = 1: find = 0
159.     WHILE i < LEN(result$) AND MID$(result$, i, 1) = "0"
160.         i = i + 1: find = 1
161.     WEND
162.     IF find = 1 THEN result$ = MID$(result$, i)
163.     subtr$ = sign$ + result$
164. END FUNCTION
165.  
166. FUNCTION add$ (a$, b$) 'add 2 positive integers assume a and b are just numbers no spaces or - signs
167.     DIM la AS INTEGER, lb AS INTEGER, m AS INTEGER, g AS INTEGER, i AS INTEGER, find AS INTEGER
168.     DIM sa AS _UNSIGNED _INTEGER64, sb AS _UNSIGNED _INTEGER64, co AS _UNSIGNED _INTEGER64
169.     DIM fa$, fb$, t$, new$, result$
170.  
171.     'first thing is to set a and b numbers to same length and multiple of 18 so can take 18 digits at a time
172.     la = LEN(a$): lb = LEN(b$)
173.     IF la > lb THEN m = INT(la / 18) + 1 ELSE m = INT(lb / 18) + 1
174.     fa$ = RIGHT$(STRING$(m * 18, "0") + a$, m * 18)
175.     fb$ = RIGHT$(STRING$(m * 18, "0") + b$, m * 18)
176.  
177.     'now taking 18 digits at a time Thanks Steve McNeill
178.     FOR g = 1 TO m
179.         sa = VAL(MID$(fa$, m * 18 - g * 18 + 1, 18))
180.         sb = VAL(MID$(fb$, m * 18 - g * 18 + 1, 18))
181.         t$ = RIGHT$(STRING$(36, "0") + _TRIM$(STR$(sa + sb + co)), 36)
182.         co = VAL(MID$(t$, 1, 18))
183.         new$ = MID$(t$, 19)
184.         result$ = new$ + result$
185.  
186.         'debug
187.         'DIM w$
188.         'PRINT a$, m * 18, sa, sb, t$, co, result$
189.         'INPUT "OK "; w$ 'OK
190.     NEXT
191.     IF co THEN result$ = STR$(co) + result$
192.     result$ = _TRIM$(result$)
193.     'strip 0
194.     i = 1: find = 0
195.     WHILE i < LEN(result$) AND MID$(result$, i, 1) = "0"
196.         i = i + 1: find = 1
197.     WEND
198.     IF find = 1 THEN result$ = MID$(result$, i)
199.     add$ = result$
200. END FUNCTION
201.  
202.  
203.  
204.  

@SMcNeill I went with 18 digits at a time with longest string and 1 digit at a time for shorter one. Doing two groups looked hairy as you would have to add$() strings up at least as many times, I think, as going digit by digit.

EDIT: found cool test to add
test$ = mult$(STRING$(50, "9"), STRING$(50, "9")) ' = n-1 nines +8 then n-1 zeros + 1 = 2 * n length
PRINT test$, LEN(test$)