Yuck String Math or What's wrong with FOO?

[Pete]

In response to Steve's "Yuck string math.." comment in thread: https://www.qb64.org/forum/index.php?topic=1091.msg102860#msg102860

Well, yes, it is messy. This would be my approach, and note this example only handles addition and  subtraction of positive or negative integers, at least for now.

I'm thinking if a few people are interested, it might be nice to have a way to calculate numbers for programs added to the new tool box section. It doesn't have to be this method, there are other ways, maybe better ones. Anyway, have a look and if anyone else has played around with ways to get your programs to convert counting numbers to base 10, please post.

Code: QB64: [Select]

1. DIM a AS _INTEGER64
2. DO
3. INPUT "Input first number:"; a
4. a$ = LTRIM$(STR$(a))
5. PRINT "Press plus or minus: ";
6. DO
7.     operator$ = INKEY$
8.     IF LEN(operator$) THEN
9.         IF operator$ = CHR$(27) THEN SYSTEM
10.         IF operator$ = "+" OR operator$ = "=" OR operator$ = "-" THEN EXIT DO
11.     END IF
12. LOOP
13. IF operator$ = "=" THEN operator$ = "+"
14. PRINT operator$
15. INPUT "Input second number:"; a
16. b$ = LTRIM$(STR$(a))
17. origa$ = a$: origb$ = b$: origoperator$ = operator$ ' Testing purposes only.
18.  
19. IF LEFT$(a$, 1) = "-" THEN sign1$ = "-" ELSE sign1$ = "+"
20. IF LEFT$(b$, 1) = "-" THEN sign2$ = "-" ELSE sign2$ = "+"
21.  
22. sign = 0
23. SELECT CASE sign1$ + operator$ + sign2$
24.     CASE "+++", "+--"
25.         operator$ = "+"
26.         IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
27.     CASE "++-", "+-+"
28.         operator$ = "-"
29.         IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
30.         IF VAL(b$) > VAL(a$) THEN SWAP a$, b$: sign = -1
31.     CASE "---", "-++"
32.         operator$ = "-"
33.         IF LEFT$(a$, 1) = "-" THEN a$ = MID$(a$, 2)
34.         IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
35.         IF VAL(b$) > VAL(a$) THEN SWAP a$, b$ ELSE sign = -1
36.     CASE "--+", "-+-"
37.         operator$ = "+"
38.         IF LEFT$(a$, 1) = "-" THEN a$ = MID$(a$, 2)
39.         IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
40.         sign = -1
41. END SELECT
42.  
43. IF LEN(a$) > LEN(b$) THEN
44.     b$ = STRING$(LEN(a$) - LEN(b$), "0") + b$
45. ELSEIF LEN(a$) < LEN(b$) THEN
46.     a$ = STRING$(LEN(b$) - LEN(a$), "0") + a$
47. END IF
48. x1$ = ""
49.  
50. SELECT CASE operator$
51.     CASE "+", "="
52.         FOR i = LEN(a$) TO 1 STEP -1
53.             x1 = VAL(MID$(a$, i, 1)) + VAL(MID$(b$, i, 1)) + carry
54.             IF x1 > 9 THEN x1 = x1 - 10: carry = 1 ELSE carry = 0
55.             x1$ = LTRIM$(STR$(x1)) + x1$
56.         NEXT
57.         IF carry THEN x1$ = "1" + x1$: carry = 0
58.     CASE "-"
59.         FOR i = LEN(a$) TO 1 STEP -1
60.             x1 = VAL(MID$(a$, i, 1)) - VAL(MID$(b$, i, 1)) + carry
61.             IF x1 < 0 THEN x1 = x1 + 10: carry = -1 ELSE carry = 0
62.             x1$ = LTRIM$(STR$(x1)) + x1$
63.         NEXT
64.         DO UNTIL LEFT$(x1$, 1) <> "0" ' Remove leading zeros.
65.             x1$ = MID$(x1$, 2)
66.         LOOP
67.         IF x1$ = "" THEN x1$ = "0": sign = 0
68.         IF carry THEN x1$ = "-" + x1$: carry = 0
69. END SELECT
70.  
71. IF sign THEN
72.     IF LEFT$(x1$, 1) = "-" THEN x1$ = MID$(x1$, 2) ELSE x1$ = "-" + x1$
73. END IF
74.  
75. PRINT " String total = "; x1$
76.  
77. SELECT CASE origoperator$ ' Testing purposes only.
78.     CASE "+"
79.         PRINT "Numeric total = "; LTRIM$(STR$(VAL(origa$) + VAL(origb$)))
80.     CASE "-"
81.         PRINT "Numeric total = "; LTRIM$(STR$(VAL(origa$) - VAL(origb$)))
82. END SELECT
83.  
84. PRINT "------------------------------"
85. LOOP

Here is the above placed in a subroutine. It can be used as a progressive integer addition / subtraction calculator. Huge numbers welcome!

Code: QB64: [Select]

1. DO
2.     INPUT "Input number:"; b$
3.     CALL stringcalc(a$, operator$, b$)
4.     IF operator$ <> "" THEN
5.         PRINT "____________________"
6.         PRINT "Sub Total = "; a$
7.     END IF
8.     PRINT "Plus or minus: ";
9.     DO
10.         operator$ = INKEY$
11.         IF LEN(operator$) THEN
12.             IF operator$ = CHR$(27) THEN SYSTEM
13.             IF operator$ = "+" OR operator$ = "=" OR operator$ = "-" THEN EXIT DO
14.         END IF
15.     LOOP
16.     IF operator$ = "=" THEN operator$ = "+"
17.     PRINT operator$
18. LOOP
19.  
20. SUB stringcalc (a$, operator$, b$)
21. IF a$ <> "" AND operator$ <> "" AND b$ <> "" THEN
22.     IF LEFT$(a$, 1) = "-" THEN sign1$ = "-" ELSE sign1$ = "+"
23.     IF LEFT$(b$, 1) = "-" THEN sign2$ = "-" ELSE sign2$ = "+"
24.  
25.     sign = 0
26.     SELECT CASE sign1$ + operator$ + sign2$
27.         CASE "+++", "+--"
28.             operator$ = "+"
29.             IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
30.         CASE "++-", "+-+"
31.             operator$ = "-"
32.             IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
33.             IF VAL(b$) > VAL(a$) THEN SWAP a$, b$: sign = -1
34.         CASE "---", "-++"
35.             operator$ = "-"
36.             IF LEFT$(a$, 1) = "-" THEN a$ = MID$(a$, 2)
37.             IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
38.             IF VAL(b$) > VAL(a$) THEN SWAP a$, b$ ELSE sign = -1
39.         CASE "--+", "-+-"
40.             operator$ = "+"
41.             IF LEFT$(a$, 1) = "-" THEN a$ = MID$(a$, 2)
42.             IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
43.             sign = -1
44.     END SELECT
45.  
46.     IF LEN(a$) > LEN(b$) THEN
47.         b$ = STRING$(LEN(a$) - LEN(b$), "0") + b$
48.     ELSEIF LEN(a$) < LEN(b$) THEN
49.         a$ = STRING$(LEN(b$) - LEN(a$), "0") + a$
50.     END IF
51.     x1$ = ""
52.  
53.     SELECT CASE operator$
54.         CASE "+", "="
55.             FOR i = LEN(a$) TO 1 STEP -1
56.                 x1 = VAL(MID$(a$, i, 1)) + VAL(MID$(b$, i, 1)) + carry
57.                 IF x1 > 9 THEN x1 = x1 - 10: carry = 1 ELSE carry = 0
58.                 x1$ = LTRIM$(STR$(x1)) + x1$
59.             NEXT
60.             IF carry THEN x1$ = "1" + x1$: carry = 0
61.         CASE "-"
62.             FOR i = LEN(a$) TO 1 STEP -1
63.                 x1 = VAL(MID$(a$, i, 1)) - VAL(MID$(b$, i, 1)) + carry
64.                 IF x1 < 0 THEN x1 = x1 + 10: carry = -1 ELSE carry = 0
65.                 x1$ = LTRIM$(STR$(x1)) + x1$
66.             NEXT
67.             DO UNTIL LEFT$(x1$, 1) <> "0" ' Remove leading zeros.
68.                 x1$ = MID$(x1$, 2)
69.             LOOP
70.             IF x1$ = "" THEN x1$ = "0": sign = 0
71.             IF carry THEN x1$ = "-" + x1$: carry = 0
72.     END SELECT
73.  
74.     IF sign THEN
75.         IF LEFT$(x1$, 1) = "-" THEN x1$ = MID$(x1$, 2) ELSE x1$ = "-" + x1$
76.     END IF
77.     a$ = x1$
78. ELSE
79.     a$ = b$
80. END IF
81. END SUB

Pete

[bplus]

Steve might have said "Yuck" to string math but he had a pretty good working set at Walter's forum, if I am recalling correctly.

[SMcNeill]

I do.  I’ll see about digging it up and sharing sometime soonish.  ;)

As a rule, I don’t like string math simply for the speed (sloooow), and I don’t have any real need for it usually.  LONGs get the majority of my work done, with _FLOATS used only when necessary (and even less often, SINGLE or DOUBLE), and string math is just a novelty needed by others much more than by me.  ;)

[Pete]

Well I think I'm at the "Yuck" part. Division. I finished addition, subtraction, and multiplication for positive and negative integers and decimal numbers, but get the steps needed for friggin' string division...

' 1) Add 20 zeros more than the divisor to the dividend.
' 2) Make a string the length of the divisor out of the left side of the dividend.
' 3) Compare cut dividend to divisor. If larger, go to next step. If smaller, bring next digit down and go onto next step.
' 4) Multiply divisor backwards from 9 until product is the same or smaller than cut dividend then save that number to a new string variable.
' 5) Subtract.
' 6) Bring down next digit.
' 7) Repeat at step 3.

I'll probably make a numeric pseudo one first, just to be certain my logic pans out. Square root strings follow a somewhat similar pattern. As far as trig functions, multiplying sine and cosine is easy enough, but there are probably some hair raising steps involved in other functions that Bill could bring to light. I'll probably stop at division, and call it a year.

Pete 

[jack]

Pete, about division, how about using Newton-Raphson with a double or _float division as the first estimate?

The steps of Newton–Raphson division are:
Calculate an estimate for the reciprocal of the divisor .
Compute successively more accurate estimates. of the reciprocal. This is where one employs the Newton–Raphson method as such.
Compute the quotient by multiplying the dividend by the reciprocal of the divisor

https://en.wikipedia.org/wiki/Division_algorithm
https://web.stanford.edu/class/ee486/doc/chap5.pdf

[Pete]

Hi Jack,

Oh crap, I'm on a plane. I'm glad I didin't type that out loud...

Anyway. Yes, I'll have to look into that as a testing method. It's probably similar to the trick to estimate square roots. For now, I've been banging it out old school. Here is what I have so far, which just works for positive and negative integers. I'll figure out how to divide decimals later. Also, this is NOT a sting function. I don't want all that extra code in the way until I get a working routine. I'll convert it then.

Code: QB64: [Select]

1. ' Division
2. ' 1) Compare each digit of dividend to divisor. If dividend is larger, exit loop. If smaller, bring next digit down and loop.
3. ' 2) Multiply divisor backwards from 9 until product is the same or smaller than cut dividend then save that number to a new string variable.
4. ' 3) Subtract.
5. ' 4) Repeat.
6.  
7. LINE INPUT "Divisor: "; a$
8. LINE INPUT "Dividend: "; b$
9. m1$ = a$
10. m2$ = b$
11. IF LEFT$(m1$, 1) = "0" THEN PRINT "Division by zero not allowed.": END
12. IF LEFT$(m1$, 1) = "-" THEN sign = -1: m1$ = MID$(m1$, 2)
13. IF LEFT$(m2$, 1) = "-" THEN
14.     IF sign THEN
15.         sign = 0
16.     ELSE
17.         sign = -1
18.     END IF
19.     m2$ = MID$(m2$, 2)
20. END IF
21. DO
22.     DO UNTIL LEN(cutd$) > LEN(m1$) OR LEN(cutd$) = LEN(m1$) AND cutd$ >= m1$
23.         cutd% = cutd% + 1: cutd$ = cutd$ + MID$(m2$, cutd%, 1)
24.         IF MID$(m2$, cutd%, 1) = "" THEN
25.             IF LEFT$(cutd$, 1) = "0" THEN divflag% = -1: EXIT DO
26.             IF INSTR(q$, ".") = 0 THEN
27.                 q$ = q$ + "."
28.             ELSE
29.                 IF LEN(MID$(q$, INSTR(q$, "."))) > 3 THEN divflag% = -2: EXIT DO
30.                 q$ = q$ + "0"
31.             END IF
32.             cutd$ = cutd$ + "0" ' No more digits to bring down.
33.         END IF
34.     LOOP
35.     IF divflag% THEN divflag% = 0: EXIT DO
36.     FOR i = 9 TO 1 STEP -1
37.         IF i * VAL(a$) <= VAL(cutd$) THEN EXIT FOR
38.     NEXT
39.     x1$ = LTRIM$(STR$(VAL(LTRIM$(STR$(i))) * VAL(m1$)))
40.     q$ = q$ + LTRIM$(STR$(i))
41.     cutd$ = LTRIM$(STR$(VAL(cutd$) - VAL(x1$)))
42. LOOP
43. IF q$ = "" THEN q$ = "0" ' dividend is zero.
44. IF LEFT$(q$, 1) = "0" THEN sign = 0
45. IF sign THEN q$ = "-" + q$
46. PRINT q$
47. RUN
48.  

[bplus]

De Ja Vu, Steve will tell you (unless I did) that you can bring down more than 1 digit at a time.

I remember having to create a routine for >, >= .... for numeric strings to judge if one number string was bigger in numeric value than the other. That's when I hit the yuck level.

[Pete]

Yes, you can have it pull down so the remainder ends up as the number of digits of the divisor, before ever having to evaluate it.

As far as the > < evaluations, simple. If the string length is smaller, it's smaller. If it's the same size, just evaluate the LEFT$(string$, 1) of each string. The larger is the larger. If the string length is larger, it's larger. Of course signs have to be considered in this evaluation, too. It's the opposite for negative, and positives are always larger than negatives.

Pete

[jack]

here's Visual Basic 3 source for string-bignum called bnc http://www.rain.org/~mkummel/tbvault.html, it may give you some ideas.

[SMcNeill]

Yes, you can have it pull down so the remainder ends up as the number of digits of the divisor, before ever having to evaluate it.

As far as the > < evaluations, simple. If the string length is smaller, it's smaller. If it's the same size, just evaluate the LEFT$(string$, 1) of each string. The larger is the larger. If the string length is larger, it's larger. Of course signs have to be considered in this evaluation, too. It's the opposite for negative, and positives are always larger than negatives.

Pete

You pull it down based on the size of your variable...

For instance “1234567890” + “2345678901”....

We can solve this byte by byte:

“0” + “1”...   1, no carry over
“9” + “0” + 0 carry over...  9, no carry over
“8” + “9” + 0 carry over...  7, carry over 1
“7” + “8” + 1 carry over...  6, carry over 1...

And so on...

OR...

We can pull numbers down 2 digits at a time, with the same process:
“90” + “01” = “91”, no carry over
“78” + “89” = “67”, carry over 1

Same process, just pull larger values so we’re not reading a single string character at a time, but instead are reading a value from 0 to 99 instead...

Half the work, twice the speed!

(And If we use INT64 values, we pull down 18 [I think] digits per pass, instead of 1.)

No need to solve byte by byte.  Solve INT64 by INT64 instead.

[Pete]

Division eats up a lot of lines of code. Decimal placement seems to require four conditions. I'm not sure if I want to try to optimize this more, or just substitute in the string math.

Code: QB64: [Select]

1. ' Division
2. ' 1) Compare each digit of dividend to divisor. If dividend is larger, exit loop. If smaller, bring next digit down and loop.
3. ' 2) Multiply divisor backwards from 9 until product is the same or smaller than cut dividend then save that number to a new string variable.
4. ' 3) Subtract.
5. ' 4) Repeat.
6.  
7. LINE INPUT "Divisor: "; a$
8. LINE INPUT "Dividend: "; b$
9. m1$ = a$
10. m2$ = b$
11. IF LEFT$(m1$, 1) = "0" AND LEN(m1$) = 1 THEN PRINT "Division by zero not allowed.": END
12. IF LEFT$(m1$, 1) = "-" THEN sign = -1: m1$ = MID$(m1$, 2)
13. IF LEFT$(m2$, 1) = "-" THEN
14.     IF sign THEN
15.         sign = 0
16.     ELSE
17.         sign = -1
18.     END IF
19.     m2$ = MID$(m2$, 2)
20. END IF
21. IF INSTR(m1$, ".") <> 0 THEN
22.     DO UNTIL RIGHT$(m1$, 1) <> "0"
23.         m1$ = MID$(m1$, 1, LEN(m1$) - 1) ' Strip off trailing zeros
24.     LOOP
25.     place% = LEN(m1$) - INSTR(m1$, ".")
26.     m1$ = MID$(m1$, 1, INSTR(m1$, ".") - 1) + MID$(m1$, INSTR(m1$, ".") + 1) ' Strip off decimal point.
27.     DO UNTIL LEFT$(m1$, 1) <> "0"
28.         m1$ = MID$(m1$, 2) ' Strip off leading zeros for divisors smaller than .1
29.     LOOP
30. END IF
31. IF INSTR(m2$, ".") <> 0 THEN
32.     m2$ = m2$ + STRING$(place% - LEN(m2$) - INSTR(m2$, "."), "0") ' Add any zeros based on the length of dividend at decimal - length of divisor at decimal. If less than zero, nothing added.
33.     place2% = INSTR(m2$, ".")
34.     DO UNTIL RIGHT$(m2$, 1) <> "0"
35.         m2$ = MID$(m2$, 1, LEN(m2$) - 1) ' Strip off trailing zeros
36.     LOOP
37.     m2$ = MID$(m2$, 1, INSTR(m2$, ".") - 1) + MID$(m2$, INSTR(m2$, ".") + 1) ' Strip off decimal point.
38. ELSE
39.     m2$ = m2$ + STRING$(place%, "0") ' Add any zeros based on the length of dividend at decimal - length of divisor at decimal. If less than zero, nothing added.
40.     place% = 0
41. END IF
42. DO
43.     DO
44.         cutd% = cutd% + 1: cutd$ = cutd$ + MID$(m2$, cutd%, 1)
45.         IF MID$(m2$, cutd%, 1) = "" THEN
46.             IF LEFT$(cutd$, 1) = "0" AND LEN(q$) > LEN(m2$) THEN divflag% = -1: EXIT DO
47.             carry = carry + 1
48.             IF carry = 1 THEN place3% = cutd% - 1 ' larger whole number divisor smaller whol number dividend.
49.             IF carry > 20 + LEN(m1$) THEN divflag% = -2: EXIT DO
50.             cutd$ = cutd$ + "0" ' No more digits to bring down.
51.         END IF
52.         IF LEN(cutd$) > LEN(m1$) OR LEN(cutd$) = LEN(m1$) AND cutd$ >= m1$ THEN EXIT DO
53.         q$ = q$ + "0"
54.     LOOP
55.     IF divflag% THEN divflag% = 0: EXIT DO
56.     FOR i = 9 TO 1 STEP -1
57.         IF i * VAL(m1$) <= VAL(cutd$) THEN EXIT FOR
58.     NEXT
59.     '-------------------------Multiply Function Needed Here.
60.     x1$ = LTRIM$(STR$(VAL(LTRIM$(STR$(i))) * VAL(m1$)))
61.     q$ = q$ + LTRIM$(STR$(i))
62.     '-------------------------Subtraction Function Needed Here.
63.     cutd$ = LTRIM$(STR$(VAL(cutd$) - VAL(x1$)))
64. LOOP
65. IF place% = 0 AND place2% = 0 THEN place% = place3%
66. IF place2% THEN place% = place% + place2% - 1
67. IF q$ = "" THEN q$ = "0": place% = 0 ' dividend is zero.
68. IF place% OR place2% THEN
69.     IF place% < LEN(q$) OR place2% THEN
70.         q$ = MID$(q$, 1, place%) + "." + MID$(q$, place% + 1)
71.     END IF
72.     DO UNTIL RIGHT$(q$, 1) <> "0"
73.         q$ = MID$(q$, 1, LEN(q$) - 1) ' Strip off trailing zeros
74.     LOOP
75.     IF RIGHT$(q$, 1) = "." THEN q$ = MID$(q$, 1, LEN(q$) - 1) ' Strip off abandoned decimal.
76. END IF
77. DO UNTIL LEFT$(q$, 1) <> "0"
78.     q$ = MID$(q$, 2) ' Strip off leading zeros
79. LOOP
80. IF q$ = "" THEN q$ = "0": sign = 0
81. IF sign THEN q$ = "-" + q$
82. PRINT q$, VAL(b$) / VAL(a$)
83. RUN
84.  

[Pete]

Hey guys, did you know this...

So I'm considering what to do about rounding the trailing decimal digit in quotients that need to be truncated. What I discovered is that QB math seems to round everything up. At least it appeared that way, when I tried...

18 / 7

My string math gets:   2.571428571428571428571
Using numeric QB math I get: 2.571428571428572

So let's look at those so my number (top) has the same number of digits as the numeric calculation...

2.571428571428571..........428571
2.571428571428572

Now you can check my number with MS Windows Calculator, which also gives 2.571428571428571, my number truncated to 15 decimal places.

So what should we do here? Do I round a remainder like ...428571 up, to match QB math, or take the math traditional road of rounding anything less than 5 down to zero?

Pete

[SMcNeill]

What’s the value after the 1?

...5714?  Or ...5715 and higher?

[Pete]

428571

Try the Windows calculator with 18 / 7. I'm not sure if the Windows calculator rounds or just truncates, as it won't display past that digit. I was just surprised QB math rounded 428571 up, so instead of the 15 digit ( the number just in front of the 4 of 428571, ending in 1, it rounded it up to 2!

2.571428571428571 Windows calculator and mine up to this number of digits, mine goes a few digits more.
2.571428571428572 QB numeric results from doing VAL("18") / VAL("7")

Edit: Windows Calculator definitely rounds last digit up. Try .2222 / .34 Windows Calculator rounds the last digit it can display up to a 9. On my string math calc function, it is 882352941, which should get rounded up to 9.

Pete

[Pete]

Well, while Steve is playing with his clock, I decided that in my math world, .5 gets rounded up. Here is what I have for division. It incorporates the multiplication and subtraction string math, so, it's a lot of lines.

It's a mess right now. I need to clean up some of the variable names... no, not those kind of names, but a$, b$, etc. just make it easier for me to make the initial framework.

I also need to put together a way I want to call these functions. Anyway, this should divide large positive or negative whole and/or decimal numbers.

Repeated numbers, like 7 / 18 = .3888888 I decided not to round, but get this, QB64 rounds that to ...89 but if we try 2 / 3, QB64 lets it stay as ...66 repeating. Apparently, QB64 only considers it repeating if all digits after the decimal are the same. I'll have to look into that while Steve is playing with his clock. Well, at least I got my "l" key working again. :D

Pete

Code: QB64: [Select]

1. LINE INPUT "Divisor: "; a$
2. LINE INPUT "Dividend: "; b$
3. d1$ = a$
4. d2$ = b$
5. IF LEFT$(d1$, 1) = "0" AND LEN(d1$) = 1 THEN PRINT "Division by zero not allowed.": END
6. IF LEFT$(d1$, 1) = "-" THEN divsign% = -1: d1$ = MID$(d1$, 2)
7. IF LEFT$(d2$, 1) = "-" THEN
8.     IF divsign% THEN
9.         divsign% = 0
10.     ELSE
11.         divsign% = -1
12.     END IF
13.     d2$ = MID$(d2$, 2)
14. END IF
15. IF INSTR(d1$, ".") <> 0 THEN
16.     DO UNTIL RIGHT$(d1$, 1) <> "0"
17.         d1$ = MID$(d1$, 1, LEN(d1$) - 1) ' Strip off trailing zeros
18.     LOOP
19.     divplace% = LEN(d1$) - INSTR(d1$, ".")
20.     d1$ = MID$(d1$, 1, INSTR(d1$, ".") - 1) + MID$(d1$, INSTR(d1$, ".") + 1) ' Strip off decimal point.
21.     DO UNTIL LEFT$(d1$, 1) <> "0"
22.         d1$ = MID$(d1$, 2) ' Strip off leading zeros for divisors smaller than .1
23.     LOOP
24. END IF
25.  
26. IF INSTR(d2$, ".") <> 0 THEN
27.     d2$ = d2$ + STRING$(divplace% - LEN(d2$) - INSTR(d2$, "."), "0") ' Add any zeros based on the length of dividend at decimal - length of divisor at decimal. If less than zero, nothing added.
28.     divplace2% = INSTR(d2$, ".")
29.     DO UNTIL RIGHT$(d2$, 1) <> "0"
30.         d2$ = MID$(d2$, 1, LEN(d2$) - 1) ' Strip off trailing zeros
31.     LOOP
32.     d2$ = MID$(d2$, 1, INSTR(d2$, ".") - 1) + MID$(d2$, INSTR(d2$, ".") + 1) ' Strip off decimal point.
33. ELSE
34.     d2$ = d2$ + STRING$(divplace%, "0") ' Add any zeros based on the length of dividend at decimal - length of divisor at decimal. If less than zero, nothing added.
35.     divplace% = 0
36. END IF
37. DO
38.     DO
39.         cutd% = cutd% + 1: cutd$ = cutd$ + MID$(d2$, cutd%, 1)
40.         IF MID$(d2$, cutd%, 1) = "" THEN
41.             IF cutd$ = STRING$(LEN(cutd$), "0") AND LEN(q$) > LEN(d2$) THEN divflag% = -1: EXIT DO
42.             divcarry = divcarry + 1
43.             IF divcarry = 1 THEN divplace3% = cutd% - 1 ' larger whole number divisor smaller whol number dividend.
44.             IF divcarry > 20 + LEN(d1$) THEN divflag% = -2: EXIT DO
45.             cutd$ = cutd$ + "0" ' No more digits to bring down.
46.         END IF
47.         IF LEN(cutd$) > LEN(d1$) OR LEN(cutd$) = LEN(d1$) AND cutd$ >= d1$ THEN EXIT DO
48.         q$ = q$ + "0"
49.     LOOP
50.     IF divflag% THEN divflag% = 0: EXIT DO
51.     FOR idiv% = 9 TO 1 STEP -1
52.         m1$ = LTRIM$(STR$(idiv%)): m2$ = d1$
53.         product$ = "": GOSUB stringmultiply
54.         tempcutd$ = cutd$ ' cutd$ can be 00 or other leading zero values.
55.         DO
56.             IF LEN(tempcutd$) = 1 THEN EXIT DO
57.             IF LEFT$(tempcutd$, 1) = "0" THEN
58.                 tempcutd$ = MID$(tempcutd$, 2)
59.             ELSE
60.                 EXIT DO
61.             END IF
62.         LOOP
63.         IF LEN(tempcutd$) > LEN(product$) OR LEN(tempcutd$) = LEN(product$) AND product$ <= tempcutd$ THEN EXIT FOR
64.     NEXT
65.     q$ = q$ + LTRIM$(STR$(idiv%))
66.     m1$ = LTRIM$(STR$(idiv%)): m2$ = d1$
67.     product$ = "": GOSUB stringmultiply
68.     operator$ = "-": a$ = cutd$: b$ = product$: GOSUB stringcalc: cutd$ = a$
69. LOOP
70. '''PRINT "Raw q$ = "; q$
71. IF divplace% = 0 AND divplace2% = 0 THEN divplace% = divplace3%
72. IF divplace2% THEN divplace% = divplace% + divplace2% - 1
73. IF q$ = "" THEN divplace% = 0 ' dividend is zero.
74. IF divplace% OR divplace2% THEN
75.     tempq$ = MID$(q$, INSTR(q$, ".") + 1)
76.     IF LEN(tempq$) >= 3 THEN
77.         IF RIGHT$(tempq$, 3) <> STRING$(3, RIGHT$(tempq$, 1)) THEN
78.             IF RIGHT$(q$, 1) < "5" THEN
79.                 q$ = MID$(q$, 1, LEN(q$) - 1)
80.             ELSE
81.                 a$ = MID$(q$, 1, LEN(q$))
82.                 b$ = STRING$(LEN(a$) - 1, "0") + LTRIM$(STR$(10 - VAL(RIGHT$(q$, 1))))
83.                 operator$ = "+": GOSUB stringcalc
84.                 q$ = a$
85.             END IF
86.         END IF
87.     END IF
88.     IF divplace% < LEN(q$) OR divplace2% THEN
89.         q$ = MID$(q$, 1, divplace%) + "." + MID$(q$, divplace% + 1)
90.     END IF
91.     DO UNTIL RIGHT$(q$, 1) <> "0"
92.         q$ = MID$(q$, 1, LEN(q$) - 1) ' Strip off trailing zeros
93.     LOOP
94.     IF RIGHT$(q$, 1) = "." THEN q$ = MID$(q$, 1, LEN(q$) - 1) ' Strip off abandoned decimal.
95. END IF
96. DO UNTIL LEFT$(q$, 1) <> "0"
97.     q$ = MID$(q$, 2) ' Strip off leading zeros
98. LOOP
99. IF q$ = "" THEN q$ = "0": divsign% = 0
100. IF divsign% THEN q$ = "-" + q$
101. PRINT "Pete's String Division: "; q$
102. PRINT "QB64 Numeric Division:  "; LTRIM$(STR$(VAL(d2$) / VAL(d1$)))
103. RUN
104.  
105. stringmultiply:
106. multsumcnt% = 0: multcarry% = 0: multplace% = 0: x1$ = ""
107. IF LEN(b$) > LEN(a$) THEN SWAP m1$, m2$
108. IF LEFT$(m1$, 1) = "-" THEN m1$ = MID$(m1$, 2): multsign% = -1
109. IF LEFT$(m2$, 1) = "-" THEN m2$ = MID$(m2$, 2): IF multsign% THEN multsign% = 0 ELSE multsign% = -1
110. IF INSTR(m1$, ".") <> 0 THEN multplace% = LEN(m1$) - INSTR(m1$, "."): m1$ = MID$(m1$, 1, INSTR(m1$, ".") - 1) + MID$(m1$, INSTR(m1$, ".") + 1)
111. IF INSTR(m2$, ".") <> 0 THEN multplace% = multplace% + LEN(m2$) - INSTR(m2$, "."): m2$ = MID$(m2$, 1, INSTR(m2$, ".") - 1) + MID$(m2$, INSTR(m2$, ".") + 1)
112.  
113. FOR multii% = LEN(m2$) TO 1 STEP -1
114.     n2$ = MID$(m2$, multii%, 1)
115.     x1$ = ""
116.     FOR multjj% = LEN(m1$) TO 1 STEP -1
117.         n1$ = MID$(m1$, multjj%, 1)
118.         multkk = VAL(n1$) * VAL(n2$) + multcarry%
119.         IF multkk > 9 THEN
120.             multcarry% = VAL(LEFT$(LTRIM$(STR$(multkk)), 1))
121.             multkk = VAL(RIGHT$(LTRIM$(STR$(multkk)), 1))
122.         ELSE
123.             multcarry% = 0
124.         END IF
125.         x1$ = LTRIM$(STR$(multkk)) + x1$
126.     NEXT
127.     IF multcarry% THEN x1$ = LTRIM$(STR$(multcarry%)) + x1$: multcarry% = 0
128.     GOSUB multsums
129. NEXT
130. IF multplace% AND product$ <> "0" THEN
131.     product$ = MID$(product$, 1, LEN(product$) - multplace%) + "." + MID$(product$, LEN(product$) - multplace% + 1)
132. END IF
133. DO UNTIL LEFT$(product$, 1) <> "0" ' Remove leading zeros.
134.     product$ = MID$(product$, 2)
135. LOOP
136. IF product$ = "" THEN product$ = "0": multsign% = 0
137. IF multsign% THEN product$ = "-" + product$
138. ' Product$ is the multiplication product variable to return.
139. RETURN
140.  
141. multsums:
142. IF product$ <> "" THEN
143.     multsumcnt% = multsumcnt% + 1
144.     x1$ = x1$ + STRING$(multsumcnt%, "0")
145.     multhh% = 0
146.     DO
147.         IF multhh% < LEN(product$) THEN ms1$ = MID$(product$, LEN(product$) - multhh%, 1) ELSE ms1$ = ""
148.         IF multhh% < LEN(x1$) THEN ms2$ = MID$(x1$, LEN(x1$) - multhh%, 1) ELSE ms2$ = ""
149.         IF ms1$ = "" AND ms2$ = "" THEN EXIT DO
150.         x1 = VAL(ms1$) + VAL(ms2$) + multcarry%
151.         IF x1 > 9 THEN x1 = x1 - 10: multcarry% = 1 ELSE multcarry% = 0
152.         xproduct$ = LTRIM$(STR$(x1)) + xproduct$
153.         multhh% = multhh% + 1
154.     LOOP
155.     IF multcarry% THEN product$ = "1" + xproduct$: multcarry% = 0 ELSE product$ = xproduct$
156.     IF multplace% THEN
157.         DO UNTIL RIGHT$(product$, 1) <> "0" ' Remove trailing zeros in a decimal sum.
158.             product$ = MID$(product$, 1, LEN(product$) - 1)
159.             multplace% = multplace% - 1
160.         LOOP
161.     END IF
162.     xproduct$ = ""
163. ELSE
164.     product$ = x1$: x1$ = ""
165. END IF
166. RETURN
167.  
168. stringcalc:
169. IF a$ <> "" AND operator$ <> "" AND b$ <> "" THEN
170.     IF INSTR(a$, ".") <> 0 THEN ' Evaluate sum for decimal fraction.
171.         sumplace% = LEN(a$) - INSTR(a$, ".")
172.         a$ = MID$(a$, 1, INSTR(a$, ".") - 1) + MID$(a$, INSTR(a$, ".") + 1) ' Strip out decimal
173.     END IF
174.     IF INSTR(b$, ".") <> 0 THEN ' Evaluate number for decimal fraction.
175.         numplace% = LEN(b$) - INSTR(b$, ".")
176.         b$ = MID$(b$, 1, INSTR(b$, ".") - 1) + MID$(b$, INSTR(b$, ".") + 1) ' Strip out decimal
177.     END IF
178.     IF sumplace% > numplace% THEN place% = sumplace% ELSE place% = numplace%
179.     IF sumplace% > place% THEN
180.         a$ = a$ + STRING$(sumplace% - place%, "0")
181.     ELSEIF place% > sumplace% THEN
182.         a$ = a$ + STRING$(place% - sumplace%, "0")
183.     END IF
184.     IF numplace% > place% THEN
185.         b$ = b$ + STRING$(numplace% - place%, "0")
186.     ELSEIF place% > numplace% THEN
187.         b$ = b$ + STRING$(place% - numplace%, "0")
188.     END IF ' END Decimal evaluations........................
189.  
190.     IF LEFT$(a$, 1) = "-" THEN sign1$ = "-" ELSE sign1$ = "+"
191.     IF LEFT$(b$, 1) = "-" THEN sign2$ = "-" ELSE sign2$ = "+"
192.  
193.     sign = 0
194.     SELECT CASE sign1$ + operator$ + sign2$
195.         CASE "+++", "+--"
196.             operator$ = "+"
197.             IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
198.         CASE "++-", "+-+"
199.             operator$ = "-"
200.             IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
201.             IF VAL(b$) > VAL(a$) THEN SWAP a$, b$: sign = -1
202.         CASE "---", "-++"
203.             operator$ = "-"
204.             IF LEFT$(a$, 1) = "-" THEN a$ = MID$(a$, 2)
205.             IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
206.             IF VAL(b$) > VAL(a$) THEN SWAP a$, b$ ELSE sign = -1
207.         CASE "--+", "-+-"
208.             operator$ = "+"
209.             IF LEFT$(a$, 1) = "-" THEN a$ = MID$(a$, 2)
210.             IF LEFT$(b$, 1) = "-" THEN b$ = MID$(b$, 2)
211.             sign = -1
212.     END SELECT
213.  
214.     IF LEN(a$) > LEN(b$) THEN
215.         b$ = STRING$(LEN(a$) - LEN(b$), "0") + b$
216.     ELSEIF LEN(a$) < LEN(b$) THEN
217.         a$ = STRING$(LEN(b$) - LEN(a$), "0") + a$
218.     END IF
219.     x1$ = ""
220.  
221.     SELECT CASE operator$
222.         CASE "+", "="
223.             FOR i = LEN(a$) TO 1 STEP -1
224.                 x1 = VAL(MID$(a$, i, 1)) + VAL(MID$(b$, i, 1)) + carry
225.                 IF x1 > 9 THEN x1 = x1 - 10: carry = 1 ELSE carry = 0
226.                 x1$ = LTRIM$(STR$(x1)) + x1$
227.             NEXT
228.             IF carry THEN x1$ = "1" + x1$: carry = 0
229.             GOSUB replacedecimal
230.         CASE "-"
231.             FOR i = LEN(a$) TO 1 STEP -1
232.                 x1 = VAL(MID$(a$, i, 1)) - VAL(MID$(b$, i, 1)) + carry
233.                 IF x1 < 0 THEN x1 = x1 + 10: carry = -1 ELSE carry = 0
234.                 x1$ = LTRIM$(STR$(x1)) + x1$
235.             NEXT
236.             IF x1$ <> "" AND x1$ <> STRING$(LEN(x1$), "0") THEN GOSUB replacedecimal
237.             DO UNTIL LEFT$(x1$, 1) <> "0" ' Remove leading zeros.
238.                 x1$ = MID$(x1$, 2)
239.             LOOP
240.             IF x1$ = "" THEN
241.                 x1$ = "0": sign = 0
242.             ELSE
243.                 IF carry THEN x1$ = "-" + x1$: carry = 0
244.             END IF
245.     END SELECT
246.  
247.     IF sign THEN
248.         IF LEFT$(x1$, 1) = "-" THEN x1$ = MID$(x1$, 2) ELSE x1$ = "-" + x1$
249.     END IF
250.     a$ = x1$
251. ELSE
252.     a$ = b$
253. END IF
254. RETURN
255.  
256. replacedecimal:
257. IF place% THEN
258.     x1$ = STRING$(place% - LEN(x1$), "0") + x1$
259.     DO UNTIL RIGHT$(x1$, 1) <> "0" ' Remove trailing zeros in a decimal sum.
260.         x1$ = MID$(x1$, 1, LEN(x1$) - 1)
261.         place% = place% - 1
262.     LOOP
263.     IF place% > 0 THEN ' Do not replace decimal if total has become an integer amount.
264.         x1$ = MID$(x1$, 1, LEN(x1$) - place%) + "." + MID$(x1$, LEN(x1$) - place% + 1)
265.     END IF
266. END IF
267. RETURN
268.